import Immutable from "immutable";
import { DataFactory, NamedNode, Term } from "n3";
import { EX } from "./namespaces";
import { uniqueSortedTerms } from "./rdf_value";
const { namedNode, literal } = DataFactory;

describe("Immutable.Set", () => {
  it("contains", () => {
    const s = Immutable.Set([EX("e1")]);
    expect(s.contains(EX("e1"))).toBeTruthy();
    expect(s.contains(EX("e2"))).toBeFalsy();
  });
});

describe("Immutable.Map", () => {
  it("gets", () => {
    let m: Immutable.Map<NamedNode, number> = Immutable.Map();
    m = m.set(EX("e1"), 5);
    expect(m.get(EX("e1"))).toEqual(5);
  });
});

const uri1 = namedNode("http://example.com/1");
const uri2 = namedNode("http://example.com/2");
const lit1 = literal("lit1");
const lit2 = literal("lit2");
const lit3 = literal("lit2", namedNode("#othertype"));
const lit4 = literal("http://example.com/1"); // sic literal (that looks like a URI)

describe("uniqueSortedTerms", () => {
  it("takes Term arrays", () => {
    const actual = uniqueSortedTerms([lit1] as Term[]);
    expect(actual).toEqual([lit1]);
  });
  it("takes NamedNode arrays", () => {
    const actual = uniqueSortedTerms([uri1] as NamedNode[]);
    expect(actual).toEqual([uri1]);
  });
  it("dedups URIs", () => {
    expect(uniqueSortedTerms([uri1, uri1, uri2])).toEqual([uri1, uri2]);
  });
  it("sorts URIs", () => {
    expect(uniqueSortedTerms([uri2, uri1])).toEqual([uri1, uri2]);
  });
  it("dedups literals", () => {
    expect(uniqueSortedTerms([lit1, lit2, lit2, lit3, lit3])).toEqual([
      lit1,
      lit2,
      lit3,
    ]);
  });
  it("sorts literals", () => {
    expect(uniqueSortedTerms([lit3, lit2, lit1])).toEqual([lit1, lit2, lit3]);
  });
  it("doesn't confuse literal URI strings", () => {
    expect(uniqueSortedTerms([uri1, lit4])).toEqual([lit4, uri1]);
  });
});