import test from "tape-catch";
import Store from "../../../src/store";

test("hasOne must return the correct type attribute", function (t) {
  t.plan(4);
  t.equal(Store.hasOne().type, "has-one");
  t.equal(Store.hasOne("example").type, "has-one");
  t.equal(Store.hasOne({}).type, "has-one");
  t.equal(Store.hasOne("example", {}).type, "has-one");
});

test("hasOne must return a serialize function that maps a relationship to data", function (t) {
  var store = new Store();
  var field = Store.hasOne();
  var resource = {
    type: "products",
    id: "1",
    category: {
      type: "categories",
      id: "2"
    }
  };
  var data = {
    "relationships": {}
  };
  t.plan(1);
  store.define("categories", {});
  store.define("products", {});
  field.serialize.call(store, resource, data, "category");
  t.deepEqual(data, {
    relationships: {
      category: {
        data: {
          type: "categories",
          id: "2"
        }
      }
    }
  });
});

test("hasOne must return a serialize function that skips missing relationships", function (t) {
  var store = new Store();
  var field = Store.hasOne();
  var resource = {
    type: "products",
    id: "1"
  };
  var data = {
    "relationships": {}
  };
  t.plan(1);
  store.define("categories", {});
  store.define("products", {});
  field.serialize.call(store, resource, data, "category");
  t.deepEqual(data, {
    relationships: {}
  });
});

test("hasOne must return a serialize function that sets null relationships as null", function (t) {
  var store = new Store();
  var field = Store.hasOne();
  var resource = {
    type: "products",
    id: "1",
    category: null
  };
  var data = {
    "relationships": {}
  };
  t.plan(1);
  store.define("categories", {});
  store.define("products", {});
  field.serialize.call(store, resource, data, "category");
  t.deepEqual(data, {
    relationships: {
      category: null
    }
  });
});

test("hasOne must return a serialize function that uses the name option if it's provided", function (t) {
  var store = new Store();
  var field = Store.hasOne("category-x");
  var resource = {
    type: "products",
    id: "1",
    category: {
      type: "categories",
      id: "2"
    },
    foo: null
  };
  var data = {
    "relationships": {}
  };
  t.plan(2);
  store.define("categories", {});
  store.define("products", {});
  field.serialize.call(store, resource, data, "category");
  t.deepEqual(data, {
    relationships: {
      "category-x": {
        data: {
          type: "categories",
          id: "2"
        }
      }
    }
  });
  data = {
    "relationships": {}
  };
  field.serialize.call(store, resource, data, "foo");
  t.deepEqual(data, {
    relationships: {
      "category-x": null
    }
  });
});

test("hasOne must return a deserialize function that maps to the relation described in the data property", function (t) {
  var store = new Store();
  var field = Store.hasOne("category");
  var data = {
    "type": "products",
    "id": "1",
    "relationships": {
      "category": {
        "data": {
          "type": "categories",
          "id": "2"
        }
      }
    }
  };
  t.plan(1);
  store.define("categories", {});
  store.define("products", {});
  t.equal(field.deserialize.call(store, data), store.find("categories", "2"));
});

test("hasOne must return a deserialize function that uses the key param when the name isn't provided", function (t) {
  var store = new Store();
  var field = Store.hasOne();
  var data = {
    "type": "products",
    "id": "1",
    "relationships": {
      "category": {
        "data": {
          "type": "categories",
          "id": "2"
        }
      }
    }
  };
  t.plan(1);
  store.define("categories", {});
  store.define("products", {});
  t.equal(field.deserialize.call(store, data, "category"), store.find("categories", "2"));
});

test("hasOne must return a deserialize function that returns null when the relationship data field is null", function (t) {
  var store = new Store();
  var data = {
    "type": "products",
    "id": "1",
    "relationships": {
      "category": {
        "data": null
      }
    }
  };
  t.plan(2);
  t.equal(Store.hasOne("category").deserialize.call(store, data), null);
  t.equal(Store.hasOne().deserialize.call(store, data, "category"), null);
});

test("hasOne must return a deserialize function that returns undefined when the relationship data field is missing", function (t) {
  var store = new Store();
  var data = {
    "type": "products",
    "id": "1",
    "relationships": {
      "category": {}
    }
  };
  t.plan(2);
  t.equal(Store.hasOne("category").deserialize.call(store, data), undefined);
  t.equal(Store.hasOne().deserialize.call(store, data, "category"), undefined);
});

test("hasOne must return a deserialize function that returns undefined when the relationship type field is missing", function (t) {
  var store = new Store();
  var data = {
    "type": "products",
    "id": "1",
    "relationships": {}
  };
  t.plan(2);
  t.equal(Store.hasOne("category").deserialize.call(store, data), undefined);
  t.equal(Store.hasOne().deserialize.call(store, data, "category"), undefined);
});

test("hasOne must return a deserialize function that returns undefined when the relationship field is missing", function (t) {
  var store = new Store();
  var data = {
    "type": "products",
    "id": "1"
  };
  t.plan(2);
  t.equal(Store.hasOne("category").deserialize.call(store, data), undefined);
  t.equal(Store.hasOne().deserialize.call(store, data, "category"), undefined);
});

test("hasOne must return a deserialize function that passes on an inverse option", function (t) {
  t.plan(2);
  t.equal(Store.hasOne({ inverse: "foo" }).inverse, "foo");
  t.equal(Store.hasOne("example", { inverse: "foo" }).inverse, "foo");
});

test("hasOne must throw an error a relationship's type hasn't been defined", function (t) {
  var store = new Store();
  var field = Store.hasOne();
  var data = {
    "type": "products",
    "id": "44",
    "relationships": {
      "category": {
        "data": { "type": "categories", "id": "34" }
      }
    }
  };
  t.plan(1);
  store.define("products", {});
  t.throws(function () {
    field.deserialize.call(store, data, "category");
  }, /Unknown type 'categories'/);
});