flint-gs 2.1.2 → 2.1.3

data/tests/bootcamp/test/core/mixins/_it.scss

@@ -0,0 +1,5 @@
+@include describe("It") {
+  @include it("should create a new test") {
+    @include should(null, true);
+  }
+}

data/tests/bootcamp/test/core/mixins/_should.scss

@@ -0,0 +1,5 @@
+@include describe("Should") {
+  @include it("should run a test") {
+    @include should(null, true);
+  }
+}

data/tests/bootcamp/test/core/mixins/_xdescribe.scss

@@ -0,0 +1,28 @@
+$test: true;
+
+@include xdescribe("xDescribe") {
+  @include it("shouldnt run") {
+    $test: false;
+    @include should(null, $test);
+  }
+
+  @include describe("normal submodule") {
+    @include it("shouldnt run sub-modules") {
+      $test: false;
+      @include should(null, $test);
+    }
+  }
+}
+
+@include describe("xDescribe") {
+  @include xdescribe("Submodule") {
+    @include it("shouldnt run sub-modules") {
+      $test: false;
+      @include should(null, $test);
+    }
+  }
+
+  @include it("should run after xdescribed sub-modules") {
+    @include should(null, $test);
+  }
+}

data/tests/bootcamp/test/core/mixins/_xit.scss

@@ -0,0 +1,12 @@
+$test: true;
+
+@include describe("xIt") {
+  @include xit("shouldnt run a test") {
+    $test: false;
+    @include should(null, $test);
+  }
+
+  @include it("should run a later test") {
+    @include should(null, $test);
+  }
+}

data/tests/bootcamp/test/matchers/_be.scss

@@ -0,0 +1,90 @@
+@include describe("be") {
+  @include it("should expect to be something") {
+    @include should( expect( 1         ), to( be( 1         )));
+    @include should( expect( a         ), to( be( a         )));
+    @include should( expect( true      ), to( be( true      )));
+    @include should( expect( false     ), to( be( false     )));
+    @include should( expect( null      ), to( be( null      )));
+  }
+
+  @include it("should expect not to be something") {
+    @include should( expect( 1         ), not-to( be( 2       )));
+    @include should( expect( a         ), not-to( be( b       )));
+    @include should( expect( true      ), not-to( be( false   )));
+    @include should( expect( false     ), not-to( be( true    )));
+    @include should( expect( null      ), not-to( be( valid   )));
+  }
+
+  @include it("should expect two equal values to be equal") {
+    @include should( expect(  1    ), to( be(  1    )));
+    @include should( expect( -1    ), to( be( -1    )));
+    @include should( expect( a     ), to( be( a     )));
+    @include should( expect( false ), to( be( false )));
+  }
+
+  @include it("should expect two non-equal values not to be equal") {
+    @include should( expect(  1    ), not-to( be( 2    )));
+    @include should( expect( -1    ), not-to( be( 1    )));
+    @include should( expect( a     ), not-to( be( b    )));
+    @include should( expect( false ), not-to( be( true )));
+  }
+
+  @include it("should expect two equal lists to be equal") {
+    @include should(expect( (1, 2, 3) ),           to( be( (1, 2, 3) )));
+    @include should(expect( ("a", "b", "c") ),     to( be( ("a", "b", "c") )));
+    @include should(expect( (true, false, true) ), to( be( (true, false, true) )));
+  }
+
+  @include it("should expect two unequal lists not to be equal") {
+    @include should(expect( (3, 2, 1) ),            not-to( be( (1, 2, 3) )));
+    @include should(expect( ("c", "b", "a") ),      not-to( be( ("a", "b", "c") )));
+    @include should(expect( (false, true, false) ), not-to( be( (true, false, true) )));
+  }
+
+  @include it("should expect two equal lists with different seperators to be equal") {
+    @include should(expect( 1 2 3 ),           to( be( (1, 2, 3) )));
+    @include should(expect( "a" "b" "c" ),     to( be( ("a", "b", "c") )));
+    @include should(expect( true false true ), to( be( (true, false, true) )));
+  }
+
+  @include it("should expect two equal lists built up programmatically to be equal") {
+    $numbers: 1, 2, 3;
+    $strings: "a", "b", "c";
+    $booleans: true, false, true;
+
+    $numbers-out:  ();
+    $strings-out:  ();
+    $booleans-out: ();
+
+    @for $i from 1 through 3 {
+      $numbers-out:  append($numbers-out,  nth($numbers,  $i), comma);
+      $strings-out:  append($strings-out,  nth($strings,  $i), comma);
+      $booleans-out: append($booleans-out, nth($booleans, $i), comma);
+    }
+
+    @include should(expect($numbers-out ), to( be( (1, 2, 3) )));
+    @include should(expect($strings-out ), to( be( ("a", "b", "c") )));
+    @include should(expect($booleans-out), to( be( (true, false, true) )));
+  }
+
+  @include it("should expect two unequal lists built up programmatically not to be equal") {
+    $numbers: 1, 2, 3;
+    $strings: "a", "b", "c";
+    $booleans: true, false, true;
+
+    $numbers-out:  ();
+    $strings-out:  ();
+    $booleans-out: ();
+
+    @for $i from 1 through 3 {
+      $numbers-out:  append($numbers-out,  nth($numbers,  $i), comma);
+      $strings-out:  append($strings-out,  nth($strings,  $i), comma);
+      $booleans-out: append($booleans-out, nth($booleans, $i), comma);
+    }
+
+    @include should(expect($numbers-out ), not-to( be( (3, 2, 1) )));
+    @include should(expect($strings-out ), not-to( be( ("c", "b", "a") )));
+    @include should(expect($booleans-out), not-to( be( (false, true, false) )));
+  }
+}
+

data/tests/bootcamp/test/matchers/_equal.scss

@@ -0,0 +1,33 @@
+@include describe("Equal") {
+  @include it("should expect two equal values to be equal") {
+    @include should( expect(  1    ), to( equal(  1    )));
+    @include should( expect( -1    ), to( equal( -1    )));
+    @include should( expect( a     ), to( equal( a     )));
+    @include should( expect( false ), to( equal( false )));
+  }
+
+  @include it("should expect two non-equal values not to be equal") {
+    @include should( expect(  1    ), not-to( equal( 2    )));
+    @include should( expect( -1    ), not-to( equal( 1    )));
+    @include should( expect( a     ), not-to( equal( b    )));
+    @include should( expect( false ), not-to( equal( true )));
+  }
+
+  @include it("should expect two equal lists to be equal") {
+    @include should(expect( (1, 2, 3) ),           to( equal( (1, 2, 3) )));
+    @include should(expect( ("a", "b", "c") ),     to( equal( ("a", "b", "c") )));
+    @include should(expect( (true, false, true) ), to( equal( (true, false, true) )));
+  }
+
+  @include it("should expect two unequal lists not to be equal") {
+    @include should(expect( (3, 2, 1) ),            not-to( equal( (1, 2, 3) )));
+    @include should(expect( ("c", "b", "a") ),      not-to( equal( ("a", "b", "c") )));
+    @include should(expect( (false, true, false) ), not-to( equal( (true, false, true) )));
+  }
+
+  @include it("should expect two equal lists with different seperators not to be equal") {
+    @include should(expect( 1 2 3 ),           not-to( equal( (1, 2, 3) )));
+    @include should(expect( "a" "b" "c" ),     not-to( equal( ("a", "b", "c") )));
+    @include should(expect( true false true ), not-to( equal( (true, false, true) )));
+  }
+}

data/tests/bootcamp/test/matchers/lists/_be-empty.scss

@@ -0,0 +1,12 @@
+@include describe("Be empty") {
+  @include it("should expect lists without content to be empty") {
+    @include should( expect( () ), to( be-empty()));
+  }
+
+  @include it("should expect lists with content to not be empty") {
+    @include should( expect( 1         ), not-to( be-empty()));
+    @include should( expect( (1, 2, 3) ), not-to( be-empty()));
+    @include should( expect( null      ), not-to( be-empty()));
+    @include should( expect( "string"  ), not-to( be-empty()));
+  }
+}

data/tests/bootcamp/test/matchers/lists/_be-longer-than.scss

@@ -0,0 +1,29 @@
+@include describe("Be longer than") {
+  @include it("should expect longer lists to be longer") {
+    @include should( expect( (1, 2, 3) ), to( be-longer-than( 2)));
+    @include should( expect( (1)       ), to( be-longer-than( 0)));
+    @include should( expect( ()        ), to( be-longer-than(-1)));
+  }
+
+  @include it("should expect shorter lists not to be longer") {
+    @include should( expect( (1, 2, 3) ), not-to( be-longer-than(4)));
+    @include should( expect( (1)       ), not-to( be-longer-than(2)));
+    @include should( expect( ()        ), not-to( be-longer-than(1)));
+  }
+
+  @include it("should expect equal length lists not to be longer") {
+    @include should( expect( (1, 2, 3) ), not-to( be-longer-than(3)));
+    @include should( expect( (1)       ), not-to( be-longer-than(1)));
+    @include should( expect( ()        ), not-to( be-longer-than(0)));
+  }
+
+  @include it("should expect other values to be longer than 0") {
+    @include should( expect( null      ), to( be-longer-than(0)));
+    @include should( expect( "string"  ), to( be-longer-than(0)));
+  }
+
+  @include it("should expect other values to be shorter than 1") {
+    @include should( expect( null      ), not-to( be-longer-than(1)));
+    @include should( expect( "string"  ), not-to( be-longer-than(1)));
+  }
+}

data/tests/bootcamp/test/matchers/lists/_be-shorter-than.scss

@@ -0,0 +1,29 @@
+@include describe("Be shorter than") {
+  @include it("should expect shorter lists to be shorter") {
+    @include should( expect( (1, 2, 3) ), to( be-shorter-than(4)));
+    @include should( expect( (1)       ), to( be-shorter-than(2)));
+    @include should( expect( ()        ), to( be-shorter-than(1)));
+  }
+
+  @include it("should expect longer lists not to be shorter") {
+    @include should( expect( (1, 2, 3) ), not-to( be-shorter-than( 2)));
+    @include should( expect( (1)       ), not-to( be-shorter-than( 0)));
+    @include should( expect( ()        ), not-to( be-shorter-than(-1)));
+  }
+
+  @include it("should expect equal length lists not to be shorter") {
+    @include should( expect( (1, 2, 3) ), not-to( be-shorter-than(3)));
+    @include should( expect( (1)       ), not-to( be-shorter-than(1)));
+    @include should( expect( ()        ), not-to( be-shorter-than(0)));
+  }
+
+  @include it("should expect other values to be shorter than 2") {
+    @include should( expect( null      ), to( be-shorter-than(2)));
+    @include should( expect( "string"  ), to( be-shorter-than(2)));
+  }
+
+  @include it("should expect other values to be shorter than 0") {
+    @include should( expect( null      ), not-to( be-shorter-than(0)));
+    @include should( expect( "string"  ), not-to( be-shorter-than(0)));
+  }
+}

data/tests/bootcamp/test/matchers/lists/_contain.scss

@@ -0,0 +1,39 @@
+@include describe("Contain") {
+  @include it("should expect list with value to contain") {
+    $list-1: true, true, true;
+    $list-2: "foo", "bar", "baz";
+    $list-3: 100, 0.2, 12;
+    $list-4: false, null, false;
+
+    @include should( expect( $list-1 ), to( contain( true  )));
+    @include should( expect( $list-2 ), to( contain( "bar" )));
+    @include should( expect( $list-3 ), to( contain( 100   )));
+    @include should( expect( $list-4 ), to( contain( null  )));
+  }
+
+  @include it("should expect list without value not to contain") {
+    $list-1: true, true, true;
+    $list-2: "foo", "bar", "baz";
+    $list-3: 100, 0.2, 12;
+    $list-4: false, null, false;
+
+    @include should( expect( $list-1 ), not-to( contain( false )));
+    @include should( expect( $list-2 ), not-to( contain( "fiz" )));
+    @include should( expect( $list-3 ), not-to( contain( 300   )));
+    @include should( expect( $list-4 ), not-to( contain( "sod" )));
+  }
+
+  @include it("should expect item with value to contain") {
+    @include should( expect( true  ), to( contain( true  )));
+    @include should( expect( "bar" ), to( contain( "bar" )));
+    @include should( expect( 100   ), to( contain( 100   )));
+    @include should( expect( null  ), to( contain( null  )));
+  }
+
+  @include it("should expect item without value not to contain") {
+    @include should( expect( true  ), not-to( contain( false )));
+    @include should( expect( "foo" ), not-to( contain( "fiz" )));
+    @include should( expect( 200   ), not-to( contain( 300   )));
+    @include should( expect( null  ), not-to( contain( "sod" )));
+  }
+}

data/tests/bootcamp/test/matchers/lists/_deep-contain.scss

@@ -0,0 +1,51 @@
+@include describe("Deep Contain") {
+  @include it("should expect deep list with value to contain") {
+    $list-1: false, (true, true);
+    $list-2: "foo", ("bar", "baz");
+    $list-3: 100, (0.2, 12);
+    $list-4: false, (null, false);
+
+    @include should( expect( $list-1 ), to( deep-contain( true  )));
+    @include should( expect( $list-2 ), to( deep-contain( "bar" )));
+    @include should( expect( $list-3 ), to( deep-contain( 0.2   )));
+    @include should( expect( $list-4 ), to( deep-contain( null  )));
+  }
+
+  @include it("should expect deep list without value not to contain") {
+    $list-1: true, (true, true);
+    $list-2: "foo", ("bar", "baz");
+    $list-3: 100, (0.2, 12);
+    $list-4: false, (null, false);
+
+    @include should( expect( $list-1 ), not-to( deep-contain( false )));
+    @include should( expect( $list-2 ), not-to( deep-contain( "fiz" )));
+    @include should( expect( $list-3 ), not-to( deep-contain( 300   )));
+    @include should( expect( $list-4 ), not-to( deep-contain( "sod" )));
+  }
+
+  @include it("should expect non-deep list with value to contain") {
+    $list-1: false, true, true;
+    $list-2: "foo", "bar", "baz";
+    $list-3: 100, 0.2, 12;
+    $list-4: false, null, false;
+
+    @include should( expect( $list-1 ), to( deep-contain( true  )));
+    @include should( expect( $list-2 ), to( deep-contain( "bar" )));
+    @include should( expect( $list-3 ), to( deep-contain( 0.2   )));
+    @include should( expect( $list-4 ), to( deep-contain( null  )));
+  }
+
+  @include it("should expect item with value to contain") {
+    @include should( expect( true  ), to( deep-contain( true  )));
+    @include should( expect( "bar" ), to( deep-contain( "bar" )));
+    @include should( expect( 100   ), to( deep-contain( 100   )));
+    @include should( expect( null  ), to( deep-contain( null  )));
+  }
+
+  @include it("should expect item without value not to contain") {
+    @include should( expect( true  ), not-to( deep-contain( false )));
+    @include should( expect( "foo" ), not-to( deep-contain( "fiz" )));
+    @include should( expect( 200   ), not-to( deep-contain( 300   )));
+    @include should( expect( null  ), not-to( deep-contain( "sod" )));
+  }
+}

data/tests/bootcamp/test/matchers/lists/_deep-equal.scss

@@ -0,0 +1,151 @@
+@include describe("Deep Equal") {
+  @include it("should expect an equal deep list to be deep equal") {
+    $list-1: false, (true, true);
+    $list-2: "foo", ("bar", "baz");
+    $list-3: 100, (0.2, 12);
+    $list-4: null, (null, false);
+
+    @include should( expect( $list-1 ), to( deep-equal( $list-1 )));
+    @include should( expect( $list-2 ), to( deep-equal( $list-2 )));
+    @include should( expect( $list-3 ), to( deep-equal( $list-3 )));
+    @include should( expect( $list-4 ), to( deep-equal( $list-4 )));
+  }
+
+  @include it("should expect an longer top level deep list not to be deep equal") {
+    $list-1a: true,       (true, (true));
+    $list-1b: true, true, (true, (true));
+
+    $list-2a: "foo",        ("bar", ("baz"));
+    $list-2b: "foo", "cha", ("bar", ("baz"));
+
+    $list-3a: 100,      (0.2, (12));
+    $list-3b: 100, 200, (0.2, (12));
+
+    $list-4a: null,        (null, false);
+    $list-4b: null, false, (null, false);
+
+    @include should( expect( $list-1a ), not-to( deep-equal( $list-1b )));
+    @include should( expect( $list-2a ), not-to( deep-equal( $list-2b )));
+    @include should( expect( $list-3a ), not-to( deep-equal( $list-3b )));
+    @include should( expect( $list-4a ), not-to( deep-equal( $list-4b )));
+  }
+
+  @include it("should expect an longer inner level deep list not to be deep equal") {
+    $list-1a: true, (      true, (true));
+    $list-1b: true, (true, true, (true));
+
+    $list-2a: "foo", (       "bar", ("baz"));
+    $list-2b: "foo", ("cha", "bar", ("baz"));
+
+    $list-3a: 100, (     0.2, 12);
+    $list-3b: 100, (200, 0.2, 12);
+
+    $list-4a: null, (       null, false);
+    $list-4b: null, (false, null, false);
+
+    @include should( expect( $list-1a ), not-to( deep-equal( $list-1b )));
+    @include should( expect( $list-2a ), not-to( deep-equal( $list-2b )));
+    @include should( expect( $list-3a ), not-to( deep-equal( $list-3b )));
+    @include should( expect( $list-4a ), not-to( deep-equal( $list-4b )));
+  }
+
+  @include it("should expect an deep list with a different top level value not to be deep equal") {
+    $list-1a: true,  (true, (true));
+    $list-1b: false, (true, (true));
+
+    $list-2a: "foo", ("bar", ("baz"));
+    $list-2b: "bar", ("bar", ("baz"));
+
+    $list-3a: 100, (0.2, (12));
+    $list-3b: 200, (0.2, (12));
+
+    $list-4a: null,  (null, false);
+    $list-4b: false, (null, false);
+
+    @include should( expect( $list-1a ), not-to( deep-equal( $list-1b )));
+    @include should( expect( $list-2a ), not-to( deep-equal( $list-2b )));
+    @include should( expect( $list-3a ), not-to( deep-equal( $list-3b )));
+    @include should( expect( $list-4a ), not-to( deep-equal( $list-4b )));
+  }
+
+  @include it("should expect an deep list with a different inner level value not to be deep equal") {
+    $list-1a: true, (false, (true));
+    $list-1b: true, (true,  (true));
+
+    $list-2a: "foo", ("bar", ("baz"));
+    $list-2b: "foo", ("foo", ("baz"));
+
+    $list-3a: 100, (0.2, (12));
+    $list-3b: 100, (200, (12));
+
+    $list-4a: null, (false, (false));
+    $list-4b: null, (null,  (false));
+
+    @include should( expect( $list-1a ), not-to( deep-equal( $list-1b )));
+    @include should( expect( $list-2a ), not-to( deep-equal( $list-2b )));
+    @include should( expect( $list-3a ), not-to( deep-equal( $list-3b )));
+    @include should( expect( $list-4a ), not-to( deep-equal( $list-4b )));
+  }
+
+  @include it("should expect an equal non-deep list to be deep equal") {
+    $list-1a: true, false, true;
+    $list-1b: true, false, true;
+
+    $list-2a: "foo", "bar", "baz";
+    $list-2b: "foo", "bar", "baz";
+
+    $list-3a: 100, 0.2, 12;
+    $list-3b: 100, 0.2, 12;
+
+    $list-4a: false, null, false;
+    $list-4b: false, null, false;
+
+    @include should( expect( $list-1a ), to( deep-equal( $list-1b )));
+    @include should( expect( $list-2a ), to( deep-equal( $list-2b )));
+    @include should( expect( $list-3a ), to( deep-equal( $list-3b )));
+    @include should( expect( $list-4a ), to( deep-equal( $list-4b )));
+  }
+
+  @include it("should expect an unequal non-deep list to be deep equal") {
+    $list-1a: true, false, true;
+    $list-1b: true, true, true;
+
+    $list-2a: "foo", "bar", "baz";
+    $list-2b: "foo", "cha", "baz";
+
+    $list-3a: 100, 0.2, 12;
+    $list-3b: 200, 0.2, 12;
+
+    $list-4a: false, null, false;
+    $list-4b: false, false, false;
+
+    @include should( expect( $list-1a ), not-to( deep-equal( $list-1b )));
+    @include should( expect( $list-2a ), not-to( deep-equal( $list-2b )));
+    @include should( expect( $list-3a ), not-to( deep-equal( $list-3b )));
+    @include should( expect( $list-4a ), not-to( deep-equal( $list-4b )));
+  }
+
+  @include it("should expect other equal values to be deep equal") {
+    @include should( expect( true  ), to( deep-equal( true  )));
+    @include should( expect( "foo" ), to( deep-equal( "foo" )));
+    @include should( expect( 1     ), to( deep-equal( 1     )));
+    @include should( expect( null  ), to( deep-equal( null  )));
+    @include should( expect( false ), to( deep-equal( false )));
+  }
+
+  @include it("should expect other unequal values to be deep equal") {
+    @include should( expect( true  ), not-to( deep-equal( false )));
+    @include should( expect( "foo" ), not-to( deep-equal( "bar" )));
+    @include should( expect( 1     ), not-to( deep-equal( 2     )));
+    @include should( expect( null  ), not-to( deep-equal( false )));
+    @include should( expect( false ), not-to( deep-equal( null  )));
+  }
+
+  @include it("should expect empty lists to be deep equal") {
+    @include should( expect( () ), to( deep-equal( () )));
+    @include should( expect( () ), to( deep-equal( () )));
+    @include should( expect( () ), to( deep-equal( () )));
+    @include should( expect( () ), to( deep-equal( () )));
+    @include should( expect( () ), to( deep-equal( () )));
+  }
+}