mailgun 0.8 → 0.11

data/lib/multimap/spec/multiset_spec.rb

@@ -5,156 +5,156 @@ describe Multiset do
 
   it "should return the multiplicity of the element" do
     set = Multiset.new([:a, :a, :b, :b, :b, :c])
-    set.multiplicity(:a).should eql(2)
-    set.multiplicity(:b).should eql(3)
-    set.multiplicity(:c).should eql(1)
+    expect(set.multiplicity(:a)).to eql(2)
+    expect(set.multiplicity(:b)).to eql(3)
+    expect(set.multiplicity(:c)).to eql(1)
   end
 
   it "should return the cardinality of the set" do
     set = Multiset.new([:a, :a, :b, :b, :b, :c])
-    set.cardinality.should eql(6)
+    expect(set.cardinality).to eql(6)
   end
 
   it "should be eql" do
     s1 = Multiset.new([:a, :b])
     s2 = Multiset.new([:b, :a])
-    s1.should eql(s2)
+    expect(s1).to eql(s2)
 
     s1 = Multiset.new([:a, :a])
     s2 = Multiset.new([:a])
-    s1.should_not eql(s2)
+    expect(s1).to_not eql(s2)
   end
 
   it "should replace the contents of the set" do
     set = Multiset[:a, :b, :b, :c]
     ret = set.replace(Multiset[:a, :a, :b, :b, :b, :c])
 
-    set.should equal(ret)
-    set.should eql(Multiset[:a, :a, :b, :b, :b, :c])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[:a, :a, :b, :b, :b, :c])
 
     set = Multiset[:a, :b, :b, :c]
     ret = set.replace([:a, :a, :b, :b, :b, :c])
 
-    set.should equal(ret)
-    set.should eql(Multiset[:a, :a, :b, :b, :b, :c])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[:a, :a, :b, :b, :b, :c])
   end
 
   it "should return true if the set is a superset of the given set" do
     set = Multiset[1, 2, 2, 3]
 
-    set.superset?(Multiset[]).should be_true
-    set.superset?(Multiset[1, 2]).should be_true
-    set.superset?(Multiset[1, 2, 3]).should be_true
-    set.superset?(Multiset[1, 2, 2, 3]).should be_true
-    set.superset?(Multiset[1, 2, 2, 2]).should be_false
-    set.superset?(Multiset[1, 2, 3, 4]).should be_false
-    set.superset?(Multiset[1, 4]).should be_false
+    expect(set.superset?(Multiset[])).to be_true
+    expect(set.superset?(Multiset[1, 2])).to be_true
+    expect(set.superset?(Multiset[1, 2, 3])).to be_true
+    expect(set.superset?(Multiset[1, 2, 2, 3])).to be_true
+    expect(set.superset?(Multiset[1, 2, 2, 2])).to be_false
+    expect(set.superset?(Multiset[1, 2, 3, 4])).to be_false
+    expect(set.superset?(Multiset[1, 4])).to be_false
   end
 
   it "should return true if the set is a proper superset of the given set" do
     set = Multiset[1, 2, 2, 3, 3]
 
-    set.proper_superset?(Multiset[]).should be_true
-    set.proper_superset?(Multiset[1, 2]).should be_true
-    set.proper_superset?(Multiset[1, 2, 3]).should be_true
-    set.proper_superset?(Multiset[1, 2, 2, 3, 3]).should be_false
-    set.proper_superset?(Multiset[1, 2, 2, 2]).should be_false
-    set.proper_superset?(Multiset[1, 2, 3, 4]).should be_false
-    set.proper_superset?(Multiset[1, 4]).should be_false
+    expect(set.proper_superset?(Multiset[])).to be_true
+    expect(set.proper_superset?(Multiset[1, 2])).to be_true
+    expect(set.proper_superset?(Multiset[1, 2, 3])).to be_true
+    expect(set.proper_superset?(Multiset[1, 2, 2, 3, 3])).to be_false
+    expect(set.proper_superset?(Multiset[1, 2, 2, 2])).to be_false
+    expect(set.proper_superset?(Multiset[1, 2, 3, 4])).to be_false
+    expect(set.proper_superset?(Multiset[1, 4])).to be_false
   end
 
   it "should return true if the set is a subset of the given set" do
     set = Multiset[1, 2, 2, 3]
 
-    set.subset?(Multiset[1, 2, 2, 3, 4]).should be_true
-    set.subset?(Multiset[1, 2, 2, 3, 3]).should be_true
-    set.subset?(Multiset[1, 2, 2, 3]).should be_true
-    set.subset?(Multiset[1, 2, 3]).should be_false
-    set.subset?(Multiset[1, 2, 2]).should be_false
-    set.subset?(Multiset[1, 2, 3]).should be_false
-    set.subset?(Multiset[]).should be_false
+    expect(set.subset?(Multiset[1, 2, 2, 3, 4])).to be_true
+    expect(set.subset?(Multiset[1, 2, 2, 3, 3])).to be_true
+    expect(set.subset?(Multiset[1, 2, 2, 3])).to be_true
+    expect(set.subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.subset?(Multiset[1, 2, 2])).to be_false
+    expect(set.subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.subset?(Multiset[])).to be_false
   end
 
   it "should return true if the set is a proper subset of the given set" do
     set = Multiset[1, 2, 2, 3, 3]
 
-    set.proper_subset?(Multiset[1, 2, 2, 3, 3, 4]).should be_true
-    set.proper_subset?(Multiset[1, 2, 2, 3, 3]).should be_false
-    set.proper_subset?(Multiset[1, 2, 3]).should be_false
-    set.proper_subset?(Multiset[1, 2, 2]).should be_false
-    set.proper_subset?(Multiset[1, 2, 3]).should be_false
-    set.proper_subset?(Multiset[]).should be_false
+    expect(set.proper_subset?(Multiset[1, 2, 2, 3, 3, 4])).to be_true
+    expect(set.proper_subset?(Multiset[1, 2, 2, 3, 3])).to be_false
+    expect(set.proper_subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.proper_subset?(Multiset[1, 2, 2])).to be_false
+    expect(set.proper_subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.proper_subset?(Multiset[])).to be_false
   end
 
   it "should delete the objects from the set and return self" do
     set = Multiset[1, 2, 2, 3]
 
     ret = set.delete(4)
-    set.should equal(ret)
-    set.should eql(Multiset[1, 2, 2, 3])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3])
 
     ret = set.delete(2)
-    set.should eql(ret)
-    set.should eql(Multiset[1, 3])
+    expect(set).to eql(ret)
+    expect(set).to eql(Multiset[1, 3])
   end
 
   it "should delete the number objects from the set and return self" do
     set = Multiset[1, 2, 2, 3]
 
     ret = set.delete(2, 1)
-    set.should eql(ret)
-    set.should eql(Multiset[1, 2, 3])
+    expect(set).to eql(ret)
+    expect(set).to eql(Multiset[1, 2, 3])
   end
 
   it "should merge the elements of the given enumerable object to the set and return self" do
     set = Multiset[1, 2, 3]
     ret = set.merge([2, 4, 5])
-    set.should equal(ret)
-    set.should eql(Multiset[1, 2, 2, 3, 4, 5])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3, 4, 5])
 
     set = Multiset[1, 2, 3]
     ret = set.merge(Multiset[2, 4, 5])
-    set.should equal(ret)
-    set.should eql(Multiset[1, 2, 2, 3, 4, 5])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3, 4, 5])
   end
 
   it "should delete every element that appears in the given enumerable object and return self" do
     set = Multiset[1, 2, 2, 3]
     ret = set.subtract([2, 4, 6])
-    set.should equal(ret)
-    set.should eql(Multiset[1, 2, 3])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 3])
   end
 
   it "should return a new set containing elements common to the set and the given enumerable object" do
     set = Multiset[1, 2, 2, 3, 4]
 
     ret = set & [2, 2, 4, 5]
-    set.should_not equal(ret)
-    ret.should eql(Multiset[2, 2, 4])
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[2, 2, 4])
 
     set = Multiset[1, 2, 3]
 
     ret = set & [1, 2, 2, 2]
-    set.should_not equal(ret)
-    ret.should eql(Multiset[1, 2])
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 2])
   end
 
   it "should return a new set containing elements exclusive between the set and the given enumerable object" do
     set = Multiset[1, 2, 3, 4, 5]
     ret = set ^ [2, 4, 5, 5]
-    set.should_not equal(ret)
-    ret.should eql(Multiset[1, 3, 5])
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 3, 5])
 
     set = Multiset[1, 2, 4, 5, 5]
     ret = set ^ [2, 3, 4, 5]
-    set.should_not equal(ret)
-    ret.should eql(Multiset[1, 3, 5])
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 3, 5])
   end
 
   it "should marshal set" do
     set = Multiset[1, 2, 3, 4, 5]
     data = Marshal.dump(set)
-    Marshal.load(data).should eql(set)
+    expect(Marshal.load(data)).to eql(set)
   end
 
   it "should dump yaml" do
@@ -162,7 +162,7 @@ describe Multiset do
 
     set = Multiset[1, 2, 3, 4, 5]
     data = YAML.dump(set)
-    YAML.load(data).should eql(set)
+    expect(YAML.load(data)).to eql(set)
   end
 end
 
@@ -174,11 +174,11 @@ describe Multiset, "with inital values" do
   end
 
   it "should return the multiplicity of the element" do
-    @set.multiplicity(1).should eql(1)
-    @set.multiplicity(2).should eql(1)
+    expect(@set.multiplicity(1)).to eql(1)
+    expect(@set.multiplicity(2)).to eql(1)
   end
 
   it "should return the cardinality of the set" do
-    @set.cardinality.should eql(2)
+    expect(@set.cardinality).to eql(2)
   end
 end

data/lib/multimap/spec/nested_multimap_spec.rb

@@ -10,54 +10,54 @@ describe NestedMultimap, "with inital values" do
 
   it "should set value at nested key" do
     @map["foo", "bar", "baz"] = 100
-    @map["foo", "bar", "baz"].should eql([100])
+    expect(@map["foo", "bar", "baz"]).to eql([100])
   end
 
   it "should allow nil keys to be set" do
     @map["b", nil] = 400
     @map["b", "c"] = 500
 
-    @map["a"].should eql([100])
-    @map["b"].should eql([200, 300])
-    @map["b", nil].should eql([200, 300, 400])
-    @map["b", "c"].should eql([200, 300, 500])
+    expect(@map["a"]).to eql([100])
+    expect(@map["b"]).to eql([200, 300])
+    expect(@map["b", nil]).to eql([200, 300, 400])
+    expect(@map["b", "c"]).to eql([200, 300, 500])
   end
 
   it "should treat missing keys as append to all" do
     @map[] = 400
-    @map["a"].should eql([100, 400])
-    @map["b"].should eql([200, 300, 400])
-    @map["c"].should eql([400])
-    @map[nil].should eql([400])
+    expect(@map["a"]).to eql([100, 400])
+    expect(@map["b"]).to eql([200, 300, 400])
+    expect(@map["c"]).to eql([400])
+    expect(@map[nil]).to eql([400])
   end
 
   it "should append the value to default containers" do
     @map << 400
-    @map["a"].should eql([100, 400])
-    @map["b"].should eql([200, 300, 400])
-    @map["c"].should eql([400])
-    @map[nil].should eql([400])
+    expect(@map["a"]).to eql([100, 400])
+    expect(@map["b"]).to eql([200, 300, 400])
+    expect(@map["c"]).to eql([400])
+    expect(@map[nil]).to eql([400])
   end
 
   it "should append the value to all containers" do
     @map << 500
-    @map["a"].should eql([100, 500])
-    @map["b"].should eql([200, 300, 500])
-    @map[nil].should eql([500])
+    expect(@map["a"]).to eql([100, 500])
+    expect(@map["b"]).to eql([200, 300, 500])
+    expect(@map[nil]).to eql([500])
   end
 
   it "default values should be copied to new containers" do
     @map << 300
     @map["x"] = 100
-    @map["x"].should eql([300, 100])
+    expect(@map["x"]).to eql([300, 100])
   end
 
   it "should list all containers" do
-    @map.containers.should sorted_eql([[100], [200, 300]])
+    expect(@map.containers).to sorted_eql([[100], [200, 300]])
   end
 
   it "should list all values" do
-    @map.values.should sorted_eql([100, 200, 300])
+    expect(@map.values).to sorted_eql([100, 200, 300])
   end
 end
 
@@ -72,52 +72,52 @@ describe NestedMultimap, "with nested values" do
   end
 
   it "should retrieve container of values for key" do
-    @map["a"].should eql([100])
-    @map["b"].should eql([200])
-    @map["c"].should eql([500])
-    @map["a", "b"].should eql([100])
-    @map["b", "c"].should eql([200, 300])
-    @map["c", "e"].should eql([400, 500])
+    expect(@map["a"]).to eql([100])
+    expect(@map["b"]).to eql([200])
+    expect(@map["c"]).to eql([500])
+    expect(@map["a", "b"]).to eql([100])
+    expect(@map["b", "c"]).to eql([200, 300])
+    expect(@map["c", "e"]).to eql([400, 500])
   end
 
   it "should append the value to default containers" do
     @map << 600
-    @map["a"].should eql([100, 600])
-    @map["b"].should eql([200, 600])
-    @map["c"].should eql([500, 600])
-    @map["a", "b"].should eql([100, 600])
-    @map["b", "c"].should eql([200, 300, 600])
-    @map["c", "e"].should eql([400, 500, 600])
-    @map[nil].should eql([600])
+    expect(@map["a"]).to eql([100, 600])
+    expect(@map["b"]).to eql([200, 600])
+    expect(@map["c"]).to eql([500, 600])
+    expect(@map["a", "b"]).to eql([100, 600])
+    expect(@map["b", "c"]).to eql([200, 300, 600])
+    expect(@map["c", "e"]).to eql([400, 500, 600])
+    expect(@map[nil]).to eql([600])
   end
 
   it "should duplicate the containers" do
     map2 = @map.dup
-    map2.should_not equal(@map)
-    map2.should eql(@map)
+    expect(map2).to_not equal(@map)
+    expect(map2).to eql(@map)
 
-    map2["a"].should eql([100])
-    map2["b"].should eql([200])
-    map2["c"].should eql([500])
-    map2["a", "b"].should eql([100])
-    map2["b", "c"].should eql([200, 300])
-    map2["c", "e"].should eql([400, 500])
+    expect(map2["a"]).to eql([100])
+    expect(map2["b"]).to eql([200])
+    expect(map2["c"]).to eql([500])
+    expect(map2["a", "b"]).to eql([100])
+    expect(map2["b", "c"]).to eql([200, 300])
+    expect(map2["c", "e"]).to eql([400, 500])
 
-    map2["a"].should_not equal(@map["a"])
-    map2["b"].should_not equal(@map["b"])
-    map2["c"].should_not equal(@map["c"])
-    map2["a", "b"].should_not equal(@map["a", "b"])
-    map2["b", "c"].should_not equal(@map["b", "c"])
-    map2["c", "e"].should_not equal(@map["c", "e"])
+    expect(map2["a"]).to_not equal(@map["a"])
+    expect(map2["b"]).to_not equal(@map["b"])
+    expect(map2["c"]).to_not equal(@map["c"])
+    expect(map2["a", "b"]).to_not equal(@map["a", "b"])
+    expect(map2["b", "c"]).to_not equal(@map["b", "c"])
+    expect(map2["c", "e"]).to_not equal(@map["c", "e"])
 
-    map2.default.should_not equal(@map.default)
-    map2.default.should eql(@map.default)
+    expect(map2.default).to_not equal(@map.default)
+    expect(map2.default).to eql(@map.default)
   end
 
   it "should iterate over each key/value pair and yield an array" do
     a = []
     @map.each { |pair| a << pair }
-    a.should sorted_eql([
+    expect(a).to sorted_eql([
       ["a", 100],
       [["b", "c"], 200],
       [["b", "c"], 300],
@@ -129,7 +129,7 @@ describe NestedMultimap, "with nested values" do
   it "should iterate over each key/container" do
     a = []
     @map.each_association { |key, container| a << [key, container] }
-    a.should sorted_eql([
+    expect(a).to sorted_eql([
       ["a", [100]],
       [["b", "c"], [200, 300]],
       [["c", "e"], [400, 500]]
@@ -139,7 +139,7 @@ describe NestedMultimap, "with nested values" do
   it "should iterate over each container plus the default" do
     a = []
     @map.each_container_with_default { |container| a << container }
-    a.should sorted_eql([
+    expect(a).to sorted_eql([
       [100],
       [200, 300],
       [200],
@@ -152,13 +152,13 @@ describe NestedMultimap, "with nested values" do
   it "should iterate over each key" do
     a = []
     @map.each_key { |key| a << key }
-    a.should sorted_eql(["a", ["b", "c"], ["b", "c"], ["c", "e"], ["c", "e"]])
+    expect(a).to sorted_eql(["a", ["b", "c"], ["b", "c"], ["c", "e"], ["c", "e"]])
   end
 
   it "should iterate over each key/value pair and yield the pair" do
     h = {}
     @map.each_pair { |key, value| (h[key] ||= []) << value }
-    h.should eql({
+    expect(h).to eql({
       "a" => [100],
       ["c", "e"] => [400, 500],
       ["b", "c"] => [200, 300]
@@ -168,23 +168,23 @@ describe NestedMultimap, "with nested values" do
   it "should iterate over each value" do
     a = []
     @map.each_value { |value| a << value }
-    a.should sorted_eql([100, 200, 300, 400, 500])
+    expect(a).to sorted_eql([100, 200, 300, 400, 500])
   end
 
   it "should list all containers" do
-    @map.containers.should sorted_eql([[100], [200, 300], [400, 500]])
+    expect(@map.containers).to sorted_eql([[100], [200, 300], [400, 500]])
   end
 
   it "should list all containers plus the default" do
-    @map.containers_with_default.should sorted_eql([[100], [200, 300], [200], [400, 500], [500], []])
+    expect(@map.containers_with_default).to sorted_eql([[100], [200, 300], [200], [400, 500], [500], []])
   end
 
   it "should return array of keys" do
-    @map.keys.should eql(["a", ["b", "c"], ["b", "c"], ["c", "e"], ["c", "e"]])
+    expect(@map.keys).to eql(["a", ["b", "c"], ["b", "c"], ["c", "e"], ["c", "e"]])
   end
 
   it "should list all values" do
-    @map.values.should sorted_eql([100, 200, 300, 400, 500])
+    expect(@map.values).to sorted_eql([100, 200, 300, 400, 500])
   end
 end