"use strict";

var assert = require("assert");
var referee = require("../referee");

describe("assert.contains", function () {
  it("should pass when array contains value", function () {
    referee.assert.contains([0, 1, 2], 1);
  });

  it("should fail when array does not contain value", function () {
    assert.throws(
      function () {
        referee.assert.contains([0, 1, 2], 3);
      },
      function (error) {
        assert.equal(error.code, "ERR_ASSERTION");
        assert.equal(
          error.message,
          "[assert.contains] Expected [ 0, 1, 2 ] to contain 3"
        );
        assert.equal(error.name, "AssertionError");
        assert.equal(error.operator, "assert.contains");
        return true;
      }
    );
  });

  it("should fail with custom message", function () {
    var message = "b776803e-4213-4061-bc82-e5f3e5b5bacd";

    assert.throws(
      function () {
        referee.assert.contains([0, 1, 2], 3, message);
      },
      function (error) {
        assert.equal(error.code, "ERR_ASSERTION");
        assert.equal(
          error.message,
          "[assert.contains] " + message + ": Expected [ 0, 1, 2 ] to contain 3"
        );
        assert.equal(error.name, "AssertionError");
        assert.equal(error.operator, "assert.contains");
        return true;
      }
    );
  });

  it("should pass when array contains the actual object", function () {
    var actual = {};

    referee.assert.contains([actual], actual);
  });

  it("should fail when array contains an equivalent object", function () {
    var actual = {};
    var notActual = {};

    assert.throws(
      function () {
        referee.assert.contains([notActual], actual);
      },
      function (error) {
        assert.equal(error.code, "ERR_ASSERTION");
        assert.equal(
          error.message,
          "[assert.contains] Expected [ {} ] to contain {}"
        );
        assert.equal(error.name, "AssertionError");
        assert.equal(error.operator, "assert.contains");
        return true;
      }
    );
  });
});

describe("refute.contains", function () {
  it("should fail when array contains value", function () {
    assert.throws(
      function () {
        referee.refute.contains([0, 1, 2], 1);
      },
      function (error) {
        assert.equal(error.code, "ERR_ASSERTION");
        assert.equal(
          error.message,
          "[refute.contains] Expected [ 0, 1, 2 ] not to contain 1"
        );
        assert.equal(error.name, "AssertionError");
        assert.equal(error.operator, "refute.contains");
        return true;
      }
    );
  });

  it("should fail with a custom message", function () {
    var message = "a1b2b6d2-42ec-4686-b550-ca651d97cfe1";

    assert.throws(
      function () {
        referee.refute.contains([0, 1, 2], 1, message);
      },
      function (error) {
        assert.equal(error.code, "ERR_ASSERTION");
        assert.equal(
          error.message,
          "[refute.contains] " +
            message +
            ": Expected [ 0, 1, 2 ] not to contain 1"
        );
        assert.equal(error.name, "AssertionError");
        assert.equal(error.operator, "refute.contains");
        return true;
      }
    );
  });

  it("should pass when array does not contain the value", function () {
    referee.refute.contains([0, 1, 2], 3);
  });

  it("should fail when array contains the actual object", function () {
    assert.throws(
      function () {
        var actual = {};

        referee.refute.contains([actual], actual);
      },
      function (error) {
        assert.equal(error.code, "ERR_ASSERTION");
        assert.equal(
          error.message,
          "[refute.contains] Expected [ {} ] not to contain {}"
        );
        assert.equal(error.name, "AssertionError");
        assert.equal(error.operator, "refute.contains");
        return true;
      }
    );
  });

  it("should not fail when array contains an equivalent object", function () {
    var actual = {};
    var notActual = {};

    referee.refute.contains([notActual], actual);
  });
});
