'use strict';

/* eslint-env mocha */

var assert = require('assert');

Object.assign = undefined;

var objectAssign = require('./');

it('should have the correct length', function () {

	assert.equal(objectAssign.length, 2);

});

it('should throw when target is not an object', function () {

	assert.throws(function () {

		objectAssign(null);

	}, TypeError);

	assert.throws(function () {

		objectAssign(undefined);

	}, TypeError);

});

it('should objectAssign own enumerable properties from source to target object', function () {

	assert.deepEqual(objectAssign({foo: 0}, {bar: 1}), {

		foo: 0,

		bar: 1

	});

	assert.deepEqual(objectAssign({foo: 0}, null, undefined), {foo: 0});

	assert.deepEqual(objectAssign({foo: 0}, null, undefined, {bar: 1}, null), {

		foo: 0,

		bar: 1

	});

});

it('should throw on null/undefined target', function () {

	assert.throws(function () {

		objectAssign(null, {});

	});

	assert.throws(function () {

		objectAssign(undefined, {});

	});

	assert.throws(function () {

		objectAssign(undefined, undefined);

	});

});

it('should not throw on null/undefined sources', function () {

	assert.doesNotThrow(function () {

		objectAssign({}, null);

	});

	assert.doesNotThrow(function () {

		objectAssign({}, undefined);

	});

	assert.doesNotThrow(function () {

		objectAssign({}, undefined, null);

	});

});

it('should support multiple sources', function () {

	assert.deepEqual(objectAssign({foo: 0}, {bar: 1}, {bar: 2}), {

		foo: 0,

		bar: 2

	});

	assert.deepEqual(objectAssign({}, {}, {foo: 1}), {foo: 1});

});

it('should only iterate own keys', function () {

	var Unicorn = function () {};

	Unicorn.prototype.rainbows = 'many';

	var unicorn = new Unicorn();

	unicorn.bar = 1;

	assert.deepEqual(objectAssign({foo: 1}, unicorn), {

		foo: 1,

		bar: 1

	});

});

it('should return the modified target object', function () {

	var target = {};

	var returned = objectAssign(target, {a: 1});

	assert.equal(returned, target);

});

it('should support `Object.create(null)` objects', function () {

	var obj = Object.create(null);

	obj.foo = true;

	assert.deepEqual(objectAssign({}, obj), {foo: true});

});

it('should preserve property order', function () {

	var letters = 'abcdefghijklmnopqrst';

	var source = {};

	letters.split('').forEach(function (letter) {

		source[letter] = letter;

	});

	var target = objectAssign({}, source);

	assert.equal(Object.keys(target).join(''), letters);

});

it('should accept primitives as target', function () {

	var target = objectAssign('abcdefg', {foo: 'bar'});

	var strObj = Object('abcdefg');

	strObj.foo = 'bar';

	assert.deepEqual(target, strObj);

});

if (typeof Symbol !== 'undefined') {

	it('should support symbol properties', function () {

		var target = {};

		var source = {};

		var sym = Symbol('foo');

		source[sym] = 'bar';

		objectAssign(target, source);

		assert.equal(target[sym], 'bar');

	});

	it('should only copy enumerable symbols', function () {

		var target = {};

		var source = {};

		var sym = Symbol('foo');

		Object.defineProperty(source, sym, {

			enumerable: false,

			value: 'bar'

		});

		objectAssign(target, source);

		assert.equal(target[sym], undefined);

	});

}