| // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| import 'package:boolean_selector/boolean_selector.dart'; |
| |
| import 'package:test/src/backend/metadata.dart'; |
| import 'package:test/src/backend/platform_selector.dart'; |
| import 'package:test/src/backend/test_platform.dart'; |
| import 'package:test/src/frontend/skip.dart'; |
| import 'package:test/src/frontend/timeout.dart'; |
| import 'package:test/test.dart'; |
| |
| void main() { |
| group("tags", () { |
| test("parses an Iterable", () { |
| expect(new Metadata.parse(tags: ["a", "b"]).tags, |
| unorderedEquals(["a", "b"])); |
| }); |
| |
| test("parses a String", () { |
| expect(new Metadata.parse(tags: "a").tags, unorderedEquals(["a"])); |
| }); |
| |
| test("parses null", () { |
| expect(new Metadata.parse().tags, unorderedEquals([])); |
| }); |
| |
| test("parse refuses an invalid type", () { |
| expect(() => new Metadata.parse(tags: 1), throwsArgumentError); |
| }); |
| |
| test("parse refuses an invalid type in a list", () { |
| expect(() => new Metadata.parse(tags: [1]), throwsArgumentError); |
| }); |
| |
| test("merges tags by computing the union of the two tag sets", () { |
| var merged = |
| new Metadata(tags: ["a", "b"]).merge(new Metadata(tags: ["b", "c"])); |
| expect(merged.tags, unorderedEquals(["a", "b", "c"])); |
| }); |
| |
| test("serializes and deserializes tags", () { |
| var metadata = new Metadata(tags: ["a", "b"]).serialize(); |
| expect( |
| new Metadata.deserialize(metadata).tags, unorderedEquals(['a', 'b'])); |
| }); |
| }); |
| |
| group("constructor", () { |
| test("returns the normal metadata if there's no forTag", () { |
| var metadata = new Metadata(verboseTrace: true, tags: ['foo', 'bar']); |
| expect(metadata.verboseTrace, isTrue); |
| expect(metadata.tags, equals(['foo', 'bar'])); |
| }); |
| |
| test("returns the normal metadata if there's no tags", () { |
| var metadata = new Metadata( |
| verboseTrace: true, |
| forTag: {new BooleanSelector.parse('foo'): new Metadata(skip: true)}); |
| expect(metadata.verboseTrace, isTrue); |
| expect(metadata.skip, isFalse); |
| expect(metadata.forTag, contains(new BooleanSelector.parse('foo'))); |
| expect(metadata.forTag[new BooleanSelector.parse('foo')].skip, isTrue); |
| }); |
| |
| test("returns the normal metadata if forTag doesn't match tags", () { |
| var metadata = new Metadata( |
| verboseTrace: true, |
| tags: ['bar', 'baz'], |
| forTag: {new BooleanSelector.parse('foo'): new Metadata(skip: true)}); |
| |
| expect(metadata.verboseTrace, isTrue); |
| expect(metadata.skip, isFalse); |
| expect(metadata.tags, unorderedEquals(['bar', 'baz'])); |
| expect(metadata.forTag, contains(new BooleanSelector.parse('foo'))); |
| expect(metadata.forTag[new BooleanSelector.parse('foo')].skip, isTrue); |
| }); |
| |
| test("resolves forTags that match tags", () { |
| var metadata = new Metadata(verboseTrace: true, tags: [ |
| 'foo', |
| 'bar', |
| 'baz' |
| ], forTag: { |
| new BooleanSelector.parse('foo'): new Metadata(skip: true), |
| new BooleanSelector.parse('baz'): new Metadata(timeout: Timeout.none), |
| new BooleanSelector.parse('qux'): new Metadata(skipReason: "blah") |
| }); |
| |
| expect(metadata.verboseTrace, isTrue); |
| expect(metadata.skip, isTrue); |
| expect(metadata.skipReason, isNull); |
| expect(metadata.timeout, equals(Timeout.none)); |
| expect(metadata.tags, unorderedEquals(['foo', 'bar', 'baz'])); |
| expect(metadata.forTag.keys, equals([new BooleanSelector.parse('qux')])); |
| }); |
| |
| test("resolves forTags that adds a behavioral tag", () { |
| var metadata = new Metadata(tags: [ |
| 'foo' |
| ], forTag: { |
| new BooleanSelector.parse('baz'): new Metadata(skip: true), |
| new BooleanSelector.parse('bar'): |
| new Metadata(verboseTrace: true, tags: ['baz']), |
| new BooleanSelector.parse('foo'): new Metadata(tags: ['bar']) |
| }); |
| |
| expect(metadata.verboseTrace, isTrue); |
| expect(metadata.skip, isTrue); |
| expect(metadata.tags, unorderedEquals(['foo', 'bar', 'baz'])); |
| expect(metadata.forTag, isEmpty); |
| }); |
| |
| test("resolves forTags that adds circular tags", () { |
| var metadata = new Metadata(tags: [ |
| 'foo' |
| ], forTag: { |
| new BooleanSelector.parse('foo'): new Metadata(tags: ['bar']), |
| new BooleanSelector.parse('bar'): new Metadata(tags: ['baz']), |
| new BooleanSelector.parse('baz'): new Metadata(tags: ['foo']) |
| }); |
| |
| expect(metadata.tags, unorderedEquals(['foo', 'bar', 'baz'])); |
| expect(metadata.forTag, isEmpty); |
| }); |
| |
| test("base metadata takes precedence over forTags", () { |
| var metadata = new Metadata(verboseTrace: true, tags: [ |
| 'foo' |
| ], forTag: { |
| new BooleanSelector.parse('foo'): new Metadata(verboseTrace: false) |
| }); |
| |
| expect(metadata.verboseTrace, isTrue); |
| }); |
| }); |
| |
| group("onPlatform", () { |
| test("parses a valid map", () { |
| var metadata = new Metadata.parse(onPlatform: { |
| "chrome": new Timeout.factor(2), |
| "vm": [new Skip(), new Timeout.factor(3)] |
| }); |
| |
| var key = metadata.onPlatform.keys.first; |
| expect(key.evaluate(TestPlatform.chrome), isTrue); |
| expect(key.evaluate(TestPlatform.vm), isFalse); |
| var value = metadata.onPlatform.values.first; |
| expect(value.timeout.scaleFactor, equals(2)); |
| |
| key = metadata.onPlatform.keys.last; |
| expect(key.evaluate(TestPlatform.vm), isTrue); |
| expect(key.evaluate(TestPlatform.chrome), isFalse); |
| value = metadata.onPlatform.values.last; |
| expect(value.skip, isTrue); |
| expect(value.timeout.scaleFactor, equals(3)); |
| }); |
| |
| test("refuses an invalid value", () { |
| expect(() { |
| new Metadata.parse(onPlatform: {"chrome": new TestOn("chrome")}); |
| }, throwsArgumentError); |
| }); |
| |
| test("refuses an invalid value in a list", () { |
| expect(() { |
| new Metadata.parse(onPlatform: { |
| "chrome": [new TestOn("chrome")] |
| }); |
| }, throwsArgumentError); |
| }); |
| |
| test("refuses an invalid platform selector", () { |
| expect(() { |
| new Metadata.parse(onPlatform: {"invalid": new Skip()}); |
| }, throwsFormatException); |
| }); |
| |
| test("refuses multiple Timeouts", () { |
| expect(() { |
| new Metadata.parse(onPlatform: { |
| "chrome": [new Timeout.factor(2), new Timeout.factor(3)] |
| }); |
| }, throwsArgumentError); |
| }); |
| |
| test("refuses multiple Skips", () { |
| expect(() { |
| new Metadata.parse(onPlatform: { |
| "chrome": [new Skip(), new Skip()] |
| }); |
| }, throwsArgumentError); |
| }); |
| }); |
| |
| group("change", () { |
| test("preserves all fields if no parameters are passed", () { |
| var metadata = new Metadata( |
| testOn: new PlatformSelector.parse("linux"), |
| timeout: new Timeout.factor(2), |
| skip: true, |
| skipReason: "just because", |
| verboseTrace: true, |
| tags: [ |
| "foo", |
| "bar" |
| ], |
| onPlatform: { |
| new PlatformSelector.parse("mac-os"): new Metadata(skip: false) |
| }, |
| forTag: { |
| new BooleanSelector.parse("slow"): |
| new Metadata(timeout: new Timeout.factor(4)) |
| }); |
| expect(metadata.serialize(), equals(metadata.change().serialize())); |
| }); |
| |
| test("updates a changed field", () { |
| var metadata = new Metadata(timeout: new Timeout.factor(2)); |
| expect(metadata.change(timeout: new Timeout.factor(3)).timeout, |
| equals(new Timeout.factor(3))); |
| }); |
| }); |
| } |