src/__tests__/append.ts

@@ -0,0 +1,11 @@
+import { from } from '..';
+
+describe('append', () => {
+  it.each([[], new Set([1, 2]), [1, 2]])('should append a new element', src => {
+    const last = 3;
+
+    const res = from(src).append(last).toArray();
+
+    expect(res[res.length - 1]).toBe(last);
+  });
+});

src/__tests__/contains.ts

@@ -0,0 +1,43 @@
+import { from } from '..';
+
+describe('contains', () => {
+  it('should return true for containing the item', () => {
+    const target = 3;
+
+    const result = from([1, 2, 3, 4]).contains(target);
+
+    expect(result).toBe(true);
+  });
+
+  it('should return false for not containing the item', () => {
+    const target = 6;
+
+    const result = from([1, 2, 3, 4]).contains(target);
+
+    expect(result).toBe(false);
+  });
+
+  it('should return true for containing the item using equality comparer', () => {
+    const target = { id: 2, foo: 'foo' };
+
+    const result = from([
+      { id: 3, foo: 'foo' },
+      { id: 2, foo: 'fooz' },
+      { id: 1, foo: 'foo' }
+    ]).contains(target, (a, b) => a.id === b.id);
+
+    expect(result).toBe(true);
+  });
+
+  it('should return false for not containing the item using equality comparer', () => {
+    const target = { id: 5, foo: 'foo' };
+
+    const result = from([
+      { id: 3, foo: 'foo' },
+      { id: 2, foo: 'fooz' },
+      { id: 1, foo: 'foo' }
+    ]).contains(target, (a, b) => a.id === b.id);
+
+    expect(result).toBe(false);
+  });
+});

src/__tests__/count.ts

@@ -0,0 +1,30 @@
+import { from } from '..';
+
+describe('count', () => {
+  it('should return the count', () => {
+    const items = [1, 2, 3];
+
+    const result = from(items).count();
+
+    expect(result).toBe(items.length);
+  });
+
+  it('should return 0 for empty', () => {
+    const result = from([]).count();
+
+    expect(result).toBe(0);
+  });
+
+  it('should return count that matches condition', () => {
+    const items = [
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 4, foo: 'asdf' }
+    ];
+
+    const result = from(items).count(x => x.id % 2 === 0);
+
+    expect(result).toBe(2);
+  });
+});

src/__tests__/distinct.ts

@@ -0,0 +1,102 @@
+import { Enumerable, from } from '..';
+
+describe('distinct', () => {
+  it('should return an Enumerable', () => {
+    const items = [1, 2, 3];
+
+    const result = from(items).distinct();
+
+    expect(result).toBeInstanceOf(Enumerable);
+  });
+
+  it('should not have duplicates', () => {
+    const items = [1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3];
+
+    const result = from(items).distinct().toArray();
+
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('should have deferred execution', () => {
+    const items = [1, 2, 3];
+
+    const result = from(items).distinct();
+
+    items.push(4, 4);
+
+    expect(result.toArray()).toEqual([1, 2, 3, 4]);
+  });
+
+  it('should return the union of two collections using passed comparer', () => {
+    const items = [
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 4, foo: 'asdf' }
+    ];
+
+    const result = from(items)
+      .distinct((a, b) => a.id === b.id)
+      .toArray();
+
+    expect(result).toEqual([
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 4, foo: 'asdf' }
+    ]);
+  });
+});
+
+describe('distinctBy', () => {
+  it('should return an Enumerable', () => {
+    const items = [1, 2, 3];
+
+    const result = from(items).distinctBy(x => x);
+
+    expect(result).toBeInstanceOf(Enumerable);
+  });
+
+  it('should return distinct items by key', () => {
+    const items = [
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 4, foo: 'asdf' }
+    ];
+
+    const result = from(items)
+      .distinctBy(x => x.id)
+      .toArray();
+
+    expect(result).toEqual([
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 4, foo: 'asdf' }
+    ]);
+  });
+
+  it('should deferred execution', () => {
+    const items = [
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' }
+    ];
+
+    const result = from(items).distinctBy(x => x.id);
+
+    items.push({ id: 4, foo: 'asdf' });
+
+    expect(result.toArray()).toEqual([
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 4, foo: 'asdf' }
+    ]);
+  });
+});

src/__tests__/except.ts

@@ -0,0 +1,133 @@
+import { Enumerable, from } from '..';
+
+describe('except', () => {
+  it('should return an Enumerable', () => {
+    const items = [1, 2, 3];
+
+    const result = from(items).except([1, 2, 3]);
+
+    expect(result).toBeInstanceOf(Enumerable);
+  });
+
+  it('should return the exception of two collections', () => {
+    const items = [0, 1, 2, 3, 6];
+
+    const otherItems = [2, 3, 4, 5];
+
+    const result = from(items).except(otherItems).toArray();
+
+    expect(result).toEqual([0, 1, 6]);
+  });
+
+  it('should return the exception of two collections when one is empty', () => {
+    const items = [1, 2, 3];
+
+    const result = from(items).except([]).toArray();
+
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('should not have duplicates', () => {
+    const items = [1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3];
+
+    const otherItems = [2, 2, 3, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5];
+
+    const result = from(items).except(otherItems).toArray();
+
+    expect(result).toEqual([1]);
+  });
+
+  it('should have deferred execution', () => {
+    const items = [1, 2, 3];
+
+    const otherItems = [2, 3, 4, 5];
+
+    const result = from(items).except(otherItems);
+
+    items.push(5, 6);
+
+    expect(result.toArray()).toEqual([1, 6]);
+  });
+
+  it('should return the exception of two collections using passed comparer', () => {
+    const items = [
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' }
+    ];
+
+    const otherItems = [
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 4, foo: 'asdf' }
+    ];
+
+    const result = from(items)
+      .except(otherItems, (a, b) => a.id === b.id)
+      .toArray();
+
+    expect(result).toEqual([{ id: 1, foo: 'asdf' }]);
+  });
+});
+
+describe('exceptBy', () => {
+  it('should return an Enumerable', () => {
+    const items = [1, 2, 3];
+
+    const result = from(items).exceptBy([1, 2, 3], x => x);
+
+    expect(result).toBeInstanceOf(Enumerable);
+  });
+
+  it('should return the exception of two collections by id', () => {
+    const items = [
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 5, foo: 'asdf' }
+    ];
+
+    const result = from(items)
+      .exceptBy([2, 3, 4], x => x.id)
+      .toArray();
+
+    expect(result).toEqual([
+      { id: 1, foo: 'asdf' },
+      { id: 5, foo: 'asdf' }
+    ]);
+  });
+
+  it('should not have duplicates by key', () => {
+    const items = [
+      { id: 1, foo: 'asdf' },
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 1, foo: 'asdf' },
+      { id: 3, foo: 'asdf' },
+      { id: 3, foo: 'asdf' }
+    ];
+
+    const result = from(items)
+      .exceptBy([2, 3, 3, 4, 4], x => x.id)
+      .toArray();
+
+    expect(result).toEqual([{ id: 1, foo: 'asdf' }]);
+  });
+
+  it('should deferred execution', () => {
+    const items = [
+      { id: 1, foo: 'asdf' },
+      { id: 2, foo: 'asdf' },
+      { id: 3, foo: 'asdf' }
+    ];
+
+    const result = from(items).exceptBy([2, 3, 4, 5], x => x.id);
+
+    items.push({ id: 6, foo: 'asdf' });
+
+    expect(result.toArray()).toEqual([
+      { id: 1, foo: 'asdf' },
+      { id: 6, foo: 'asdf' }
+    ]);
+  });
+});