test/version_union_test.dart

// 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:test/test.dart';

import 'package:pub_semver/pub_semver.dart';

import 'utils.dart';

main() {
  group('factory', () {
    test('ignores empty constraints', () {
      expect(
          new VersionConstraint.unionOf([
            VersionConstraint.empty,
            VersionConstraint.empty,
            v123,
            VersionConstraint.empty
          ]),
          equals(v123));

      expect(
          new VersionConstraint.unionOf(
              [VersionConstraint.empty, VersionConstraint.empty]),
          isEmpty);
    });

    test('returns an empty constraint for an empty list', () {
      expect(new VersionConstraint.unionOf([]), isEmpty);
    });

    test('any constraints override everything', () {
      expect(
          new VersionConstraint.unionOf([
            v123,
            VersionConstraint.any,
            v200,
            new VersionRange(min: v234, max: v250)
          ]),
          equals(VersionConstraint.any));
    });

    test('flattens other unions', () {
      expect(
          new VersionConstraint.unionOf([
            v072,
            new VersionConstraint.unionOf([v123, v124]),
            v250
          ]),
          equals(new VersionConstraint.unionOf([v072, v123, v124, v250])));
    });

    test('returns a single merged range as-is', () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v080, max: v140),
            new VersionRange(min: v123, max: v200)
          ]),
          equals(new VersionRange(min: v080, max: v200)));
    });
  });

  group('equality', () {
    test("doesn't depend on original order", () {
      expect(
          new VersionConstraint.unionOf([
            v250,
            new VersionRange(min: v201, max: v234),
            v124,
            v072,
            new VersionRange(min: v080, max: v114),
            v123
          ]),
          equals(new VersionConstraint.unionOf([
            v072,
            new VersionRange(min: v080, max: v114),
            v123,
            v124,
            new VersionRange(min: v201, max: v234),
            v250
          ])));
    });

    test("merges overlapping ranges", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v072),
            new VersionRange(min: v010, max: v080),
            new VersionRange(min: v114, max: v124),
            new VersionRange(min: v123, max: v130)
          ]),
          equals(new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v080),
            new VersionRange(min: v114, max: v130)
          ])));
    });

    test("merges adjacent ranges", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v072, includeMax: true),
            new VersionRange(min: v072, max: v080),
            new VersionRange(
                min: v114, max: v124, alwaysIncludeMaxPreRelease: true),
            new VersionRange(min: v124, max: v130, includeMin: true),
            new VersionRange(
                min: v130.firstPreRelease, max: v200, includeMin: true)
          ]),
          equals(new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v080),
            new VersionRange(min: v114, max: v200)
          ])));
    });

    test("doesn't merge not-quite-adjacent ranges", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v114, max: v124),
            new VersionRange(min: v124, max: v130, includeMin: true)
          ]),
          isNot(equals(new VersionRange(min: v114, max: v130))));

      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v072),
            new VersionRange(min: v072, max: v080)
          ]),
          isNot(equals(new VersionRange(min: v003, max: v080))));
    });

    test("merges version numbers into ranges", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v072),
            v010,
            new VersionRange(min: v114, max: v124),
            v123
          ]),
          equals(new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v072),
            new VersionRange(min: v114, max: v124)
          ])));
    });

    test("merges adjacent version numbers into ranges", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(
                min: v003, max: v072, alwaysIncludeMaxPreRelease: true),
            v072,
            v114,
            new VersionRange(min: v114, max: v124),
            v124.firstPreRelease
          ]),
          equals(new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v072, includeMax: true),
            new VersionRange(
                min: v114,
                max: v124.firstPreRelease,
                includeMin: true,
                includeMax: true)
          ])));
    });

    test("doesn't merge not-quite-adjacent version numbers into ranges", () {
      expect(
          new VersionConstraint.unionOf(
              [new VersionRange(min: v003, max: v072), v072]),
          isNot(equals(
              new VersionRange(min: v003, max: v072, includeMax: true))));
    });
  });

  test('isEmpty returns false', () {
    expect(
        new VersionConstraint.unionOf([
          new VersionRange(min: v003, max: v080),
          new VersionRange(min: v123, max: v130),
        ]),
        isNot(isEmpty));
  });

  test('isAny returns false', () {
    expect(
        new VersionConstraint.unionOf([
          new VersionRange(min: v003, max: v080),
          new VersionRange(min: v123, max: v130),
        ]).isAny,
        isFalse);
  });

  test('allows() allows anything the components allow', () {
    var union = new VersionConstraint.unionOf([
      new VersionRange(min: v003, max: v080),
      new VersionRange(min: v123, max: v130),
      v200
    ]);

    expect(union, allows(v010));
    expect(union, doesNotAllow(v080));
    expect(union, allows(v124));
    expect(union, doesNotAllow(v140));
    expect(union, allows(v200));
  });

  group('allowsAll()', () {
    test('for a version, returns true if any component allows the version', () {
      var union = new VersionConstraint.unionOf([
        new VersionRange(min: v003, max: v080),
        new VersionRange(min: v123, max: v130),
        v200
      ]);

      expect(union.allowsAll(v010), isTrue);
      expect(union.allowsAll(v080), isFalse);
      expect(union.allowsAll(v124), isTrue);
      expect(union.allowsAll(v140), isFalse);
      expect(union.allowsAll(v200), isTrue);
    });

    test(
        'for a version range, returns true if any component allows the whole '
        'range', () {
      var union = new VersionConstraint.unionOf([
        new VersionRange(min: v003, max: v080),
        new VersionRange(min: v123, max: v130)
      ]);

      expect(union.allowsAll(new VersionRange(min: v003, max: v080)), isTrue);
      expect(union.allowsAll(new VersionRange(min: v010, max: v072)), isTrue);
      expect(union.allowsAll(new VersionRange(min: v010, max: v124)), isFalse);
    });

    group('for a union,', () {
      var union = new VersionConstraint.unionOf([
        new VersionRange(min: v003, max: v080),
        new VersionRange(min: v123, max: v130)
      ]);

      test('returns true if every constraint matches a different constraint',
          () {
        expect(
            union.allowsAll(new VersionConstraint.unionOf([
              new VersionRange(min: v010, max: v072),
              new VersionRange(min: v124, max: v130)
            ])),
            isTrue);
      });

      test('returns true if every constraint matches the same constraint', () {
        expect(
            union.allowsAll(new VersionConstraint.unionOf([
              new VersionRange(min: v003, max: v010),
              new VersionRange(min: v072, max: v080)
            ])),
            isTrue);
      });

      test("returns false if there's an unmatched constraint", () {
        expect(
            union.allowsAll(new VersionConstraint.unionOf([
              new VersionRange(min: v010, max: v072),
              new VersionRange(min: v124, max: v130),
              new VersionRange(min: v140, max: v200)
            ])),
            isFalse);
      });

      test("returns false if a constraint isn't fully matched", () {
        expect(
            union.allowsAll(new VersionConstraint.unionOf([
              new VersionRange(min: v010, max: v114),
              new VersionRange(min: v124, max: v130)
            ])),
            isFalse);
      });
    });
  });

  group('allowsAny()', () {
    test('for a version, returns true if any component allows the version', () {
      var union = new VersionConstraint.unionOf([
        new VersionRange(min: v003, max: v080),
        new VersionRange(min: v123, max: v130),
        v200
      ]);

      expect(union.allowsAny(v010), isTrue);
      expect(union.allowsAny(v080), isFalse);
      expect(union.allowsAny(v124), isTrue);
      expect(union.allowsAny(v140), isFalse);
      expect(union.allowsAny(v200), isTrue);
    });

    test(
        'for a version range, returns true if any component allows part of '
        'the range', () {
      var union = new VersionConstraint.unionOf(
          [new VersionRange(min: v003, max: v080), v123]);

      expect(union.allowsAny(new VersionRange(min: v010, max: v114)), isTrue);
      expect(union.allowsAny(new VersionRange(min: v114, max: v124)), isTrue);
      expect(union.allowsAny(new VersionRange(min: v124, max: v130)), isFalse);
    });

    group('for a union,', () {
      var union = new VersionConstraint.unionOf([
        new VersionRange(min: v010, max: v080),
        new VersionRange(min: v123, max: v130)
      ]);

      test('returns true if any constraint matches', () {
        expect(
            union.allowsAny(new VersionConstraint.unionOf(
                [v072, new VersionRange(min: v200, max: v300)])),
            isTrue);

        expect(
            union.allowsAny(new VersionConstraint.unionOf(
                [v003, new VersionRange(min: v124, max: v300)])),
            isTrue);
      });

      test("returns false if no constraint matches", () {
        expect(
            union.allowsAny(new VersionConstraint.unionOf([
              v003,
              new VersionRange(min: v130, max: v140),
              new VersionRange(min: v140, max: v200)
            ])),
            isFalse);
      });
    });
  });

  group("intersect()", () {
    test("with an overlapping version, returns that version", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v010, max: v080),
            new VersionRange(min: v123, max: v140)
          ]).intersect(v072),
          equals(v072));
    });

    test("with a non-overlapping version, returns an empty constraint", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v010, max: v080),
            new VersionRange(min: v123, max: v140)
          ]).intersect(v300),
          isEmpty);
    });

    test("with an overlapping range, returns that range", () {
      var range = new VersionRange(min: v072, max: v080);
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v010, max: v080),
            new VersionRange(min: v123, max: v140)
          ]).intersect(range),
          equals(range));
    });

    test("with a non-overlapping range, returns an empty constraint", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v010, max: v080),
            new VersionRange(min: v123, max: v140)
          ]).intersect(new VersionRange(min: v080, max: v123)),
          isEmpty);
    });

    test("with a parially-overlapping range, returns the overlapping parts",
        () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v010, max: v080),
            new VersionRange(min: v123, max: v140)
          ]).intersect(new VersionRange(min: v072, max: v130)),
          equals(new VersionConstraint.unionOf([
            new VersionRange(min: v072, max: v080),
            new VersionRange(min: v123, max: v130)
          ])));
    });

    group("for a union,", () {
      var union = new VersionConstraint.unionOf([
        new VersionRange(min: v003, max: v080),
        new VersionRange(min: v123, max: v130)
      ]);

      test("returns the overlapping parts", () {
        expect(
            union.intersect(new VersionConstraint.unionOf([
              v010,
              new VersionRange(min: v072, max: v124),
              new VersionRange(min: v124, max: v130)
            ])),
            equals(new VersionConstraint.unionOf([
              v010,
              new VersionRange(min: v072, max: v080),
              new VersionRange(min: v123, max: v124),
              new VersionRange(min: v124, max: v130)
            ])));
      });

      test("drops parts that don't match", () {
        expect(
            union.intersect(new VersionConstraint.unionOf([
              v003,
              new VersionRange(min: v072, max: v080),
              new VersionRange(min: v080, max: v123)
            ])),
            equals(new VersionRange(min: v072, max: v080)));
      });
    });
  });

  group("difference()", () {
    test("ignores ranges that don't intersect", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v072, max: v080),
            new VersionRange(min: v123, max: v130)
          ]).difference(new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v010),
            new VersionRange(min: v080, max: v123),
            new VersionRange(min: v140)
          ])),
          equals(new VersionConstraint.unionOf([
            new VersionRange(min: v072, max: v080),
            new VersionRange(min: v123, max: v130)
          ])));
    });

    test("removes overlapping portions", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v010, max: v080),
            new VersionRange(min: v123, max: v130)
          ]).difference(new VersionConstraint.unionOf([
            new VersionRange(min: v003, max: v072),
            new VersionRange(min: v124)
          ])),
          equals(new VersionConstraint.unionOf([
            new VersionRange(
                min: v072.firstPreRelease, max: v080, includeMin: true),
            new VersionRange(min: v123, max: v124, includeMax: true)
          ])));
    });

    test("removes multiple portions from the same range", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v010, max: v114),
            new VersionRange(min: v130, max: v200)
          ]).difference(new VersionConstraint.unionOf([v072, v080])),
          equals(new VersionConstraint.unionOf([
            new VersionRange(
                min: v010, max: v072, alwaysIncludeMaxPreRelease: true),
            new VersionRange(
                min: v072, max: v080, alwaysIncludeMaxPreRelease: true),
            new VersionRange(min: v080, max: v114),
            new VersionRange(min: v130, max: v200)
          ])));
    });

    test("removes the same range from multiple ranges", () {
      expect(
          new VersionConstraint.unionOf([
            new VersionRange(min: v010, max: v072),
            new VersionRange(min: v080, max: v123),
            new VersionRange(min: v124, max: v130),
            new VersionRange(min: v200, max: v234),
            new VersionRange(min: v250, max: v300)
          ]).difference(new VersionRange(min: v114, max: v201)),
          equals(new VersionConstraint.unionOf([
            new VersionRange(min: v010, max: v072),
            new VersionRange(min: v080, max: v114, includeMax: true),
            new VersionRange(
                min: v201.firstPreRelease, max: v234, includeMin: true),
            new VersionRange(min: v250, max: v300)
          ])));
    });
  });
}