mailgun 0.8 → 0.11

data/lib/multimap/spec/set_examples.rb

@@ -4,16 +4,16 @@ shared_examples_for Set do
     Multiset[nil]
     Multiset[1, 2, 3]
 
-    Multiset[].size.should eql(0)
-    Multiset[nil].size.should eql(1)
-    Multiset[[]].size.should eql(1)
-    Multiset[[nil]].size.should eql(1)
+    expect(Multiset[].size).to eql(0)
+    expect(Multiset[nil].size).to eql(1)
+    expect(Multiset[[]].size).to eql(1)
+    expect(Multiset[[nil]].size).to eql(1)
 
     set = Multiset[2, 4, 6, 4]
-    Multiset.new([2, 4, 6]).should_not eql(set)
+    expect(Multiset.new([2, 4, 6])).to_not eql(set)
 
     set = Multiset[2, 4, 6, 4]
-    Multiset.new([2, 4, 6, 4]).should eql(set)
+    expect(Multiset.new([2, 4, 6, 4])).to eql(set)
   end
 
   it "should create a new set containing the elements of the given enumerable object" do
@@ -23,247 +23,247 @@ shared_examples_for Set do
     Multiset.new([1, 2])
     Multiset.new('a'..'c')
 
-    lambda { Multiset.new(false) }.should raise_error
-    lambda { Multiset.new(1) }.should raise_error
-    lambda { Multiset.new(1, 2) }.should raise_error
+    expect(lambda { Multiset.new(false) }).to raise_error
+    expect(lambda { Multiset.new(1) }).to raise_error
+    expect(lambda { Multiset.new(1, 2) }).to raise_error
 
-    Multiset.new().size.should eql(0)
-    Multiset.new(nil).size.should eql(0)
-    Multiset.new([]).size.should eql(0)
-    Multiset.new([nil]).size.should eql(1)
+    expect(Multiset.new().size).to eql(0)
+    expect(Multiset.new(nil).size).to eql(0)
+    expect(Multiset.new([]).size).to eql(0)
+    expect(Multiset.new([nil]).size).to eql(1)
 
     ary = [2, 4, 6, 4]
     set = Multiset.new(ary)
     ary.clear
-    set.should_not be_empty
-    set.size.should eql(4)
+    expect(set).to_not be_empty
+    expect(set.size).to eql(4)
 
     ary = [1, 2, 3]
 
     s = Multiset.new(ary) { |o| o * 2 }
-    [2, 4, 6].should eql(s.sort)
+    expect([2, 4, 6]).to eql(s.sort)
   end
 
   it "should duplicate set" do
     set1 = Multiset[1, 2]
     set2 = set1.dup
 
-    set1.should_not equal(set2)
+    expect(set1).to_not equal(set2)
 
-    set1.should eql(set2)
+    expect(set1).to eql(set2)
 
     set1.add(3)
 
-    set1.should_not eql(set2)
+    expect(set1).to_not eql(set2)
   end
 
   it "should return the number of elements" do
-    Multiset[].size.should eql(0)
-    Multiset[1, 2].size.should eql(2)
-    Multiset[1, 2, 1].size.should eql(3)
+    expect(Multiset[].size).to eql(0)
+    expect(Multiset[1, 2].size).to eql(2)
+    expect(Multiset[1, 2, 1].size).to eql(3)
   end
 
   it "should return true if the set contains no elements" do
-    Multiset[].should be_empty
-    Multiset[1, 2].should_not be_empty
+    expect(Multiset[]).to be_empty
+    expect(Multiset[1, 2]).to_not be_empty
   end
 
   it "should remove all elements and returns self" do
     set = Multiset[1, 2]
     ret = set.clear
 
-    set.should equal(ret)
-    set.should be_empty
+    expect(set).to equal(ret)
+    expect(set).to be_empty
   end
 
   it "should replaces the contents of the set with the contents of the given enumerable object and returns self" do
     set = Multiset[1, 2]
     ret = set.replace('a'..'c')
 
-    set.should equal(ret)
-    set.should eql(Multiset['a', 'b', 'c'])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset['a', 'b', 'c'])
   end
 
   it "should convert the set to an array" do
     set = Multiset[1, 2, 3, 2]
     ary = set.to_a
 
-    ary.sort.should eql([1, 2, 2, 3])
+    expect(ary.sort).to eql([1, 2, 2, 3])
   end
 
   it "should return true if the set contains the given object" do
     set = Multiset[1, 2, 3]
 
-    set.include?(1).should be_true
-    set.include?(2).should be_true
-    set.include?(3).should be_true
-    set.include?(0).should be_false
-    set.include?(nil).should be_false
+    expect(set.include?(1)).to be_true
+    expect(set.include?(2)).to be_true
+    expect(set.include?(3)).to be_true
+    expect(set.include?(0)).to be_false
+    expect(set.include?(nil)).to be_false
 
     set = Multiset["1", nil, "2", nil, "0", "1", false]
-    set.include?(nil).should be_true
-    set.include?(false).should be_true
-    set.include?("1").should be_true
-    set.include?(0).should be_false
-    set.include?(true).should be_false
+    expect(set.include?(nil)).to be_true
+    expect(set.include?(false)).to be_true
+    expect(set.include?("1")).to be_true
+    expect(set.include?(0)).to be_false
+    expect(set.include?(true)).to be_false
   end
 
   it "should return true if the set is a superset of the given set" do
     set = Multiset[1, 2, 3]
 
-    lambda { set.superset?() }.should raise_error
-    lambda { set.superset?(2) }.should raise_error
-    lambda { set.superset?([2]) }.should raise_error
+    expect(lambda { set.superset?() }).to raise_error
+    expect(lambda { set.superset?(2) }).to raise_error
+    expect(lambda { set.superset?([2]) }).to raise_error
 
-    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, 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, 3, 4])).to be_false
+    expect(set.superset?(Multiset[1, 4])).to be_false
 
-    Multiset[].superset?(Multiset[]).should be_true
+    expect(Multiset[].superset?(Multiset[])).to be_true
   end
 
   it "should return true if the set is a proper superset of the given set" do
     set = Multiset[1, 2, 3]
 
-    lambda { set.proper_superset?() }.should raise_error
-    lambda { set.proper_superset?(2) }.should raise_error
-    lambda { set.proper_superset?([2]) }.should raise_error
+    expect(lambda { set.proper_superset?() }).to raise_error
+    expect(lambda { set.proper_superset?(2) }).to raise_error
+    expect(lambda { set.proper_superset?([2]) }).to raise_error
 
-    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_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_false
+    expect(set.proper_superset?(Multiset[1, 2, 3, 4])).to be_false
+    expect(set.proper_superset?(Multiset[1, 4])).to be_false
 
-    Multiset[].proper_superset?(Multiset[]).should be_false
+    expect(Multiset[].proper_superset?(Multiset[])).to be_false
   end
 
   it "should return true if the set is a subset of the given set" do
     set = Multiset[1, 2, 3]
 
-    lambda { set.subset?() }.should raise_error
-    lambda { set.subset?(2) }.should raise_error
-    lambda { set.subset?([2]) }.should raise_error
+    expect(lambda { set.subset?() }).to raise_error
+    expect(lambda { set.subset?(2) }).to raise_error
+    expect(lambda { set.subset?([2]) }).to raise_error
 
-    set.subset?(Multiset[1, 2, 3, 4]).should be_true
-    set.subset?(Multiset[1, 2, 3]).should be_true
-    set.subset?(Multiset[1, 2]).should be_false
-    set.subset?(Multiset[]).should be_false
+    expect(set.subset?(Multiset[1, 2, 3, 4])).to be_true
+    expect(set.subset?(Multiset[1, 2, 3])).to be_true
+    expect(set.subset?(Multiset[1, 2])).to be_false
+    expect(set.subset?(Multiset[])).to be_false
 
-    Multiset[].subset?(Multiset[1]).should be_true
-    Multiset[].subset?(Multiset[]).should be_true
+    expect(Multiset[].subset?(Multiset[1])).to be_true
+    expect(Multiset[].subset?(Multiset[])).to be_true
   end
 
   it "should return true if the set is a proper subset of the given set" do
     set = Multiset[1, 2, 3]
 
-    lambda { set.proper_subset?() }.should raise_error
-    lambda { set.proper_subset?(2) }.should raise_error
-    lambda { set.proper_subset?([2]) }.should raise_error
+    expect(lambda { set.proper_subset?() }).to raise_error
+    expect(lambda { set.proper_subset?(2) }).to raise_error
+    expect(lambda { set.proper_subset?([2]) }).to raise_error
 
-    set.proper_subset?(Multiset[1, 2, 3, 4]).should be_true
-    set.proper_subset?(Multiset[1, 2, 3]).should be_false
-    set.proper_subset?(Multiset[1, 2]).should be_false
-    set.proper_subset?(Multiset[]).should be_false
+    expect(set.proper_subset?(Multiset[1, 2, 3, 4])).to be_true
+    expect(set.proper_subset?(Multiset[1, 2, 3])).to be_false
+    expect(set.proper_subset?(Multiset[1, 2])).to be_false
+    expect(set.proper_subset?(Multiset[])).to be_false
 
-    Multiset[].proper_subset?(Multiset[]).should be_false
+    expect(Multiset[].proper_subset?(Multiset[])).to be_false
   end
 
   it "should add the given object to the set and return self" do
     set = Multiset[1, 2, 3]
 
     ret = set.add(2)
-    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.add(4)
-    set.should equal(ret)
-    set.should eql(Multiset[1, 2, 2, 3, 4])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3, 4])
   end
 
   it "should delete the given object from the set and return self" do
     set = Multiset[1, 2, 3]
 
     ret = set.delete(4)
-    set.should equal(ret)
-    set.should eql(Multiset[1, 2, 3])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 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 every element of the set for which block evaluates to true, and return self" do
     set = Multiset.new(1..10)
     ret = set.delete_if { |i| i > 10 }
-    set.should equal(ret)
-    set.should eql(Multiset.new(1..10))
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset.new(1..10))
 
     set = Multiset.new(1..10)
     ret = set.delete_if { |i| i % 3 == 0 }
-    set.should equal(ret)
-    set.should eql(Multiset[1, 2, 4, 5, 7, 8, 10])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 4, 5, 7, 8, 10])
   end
 
   it "should deletes every element of the set for which block evaluates to true but return nil if no changes were made" do
     set = Multiset.new(1..10)
 
     ret = set.reject! { |i| i > 10 }
-    ret.should be_nil
-    set.should eql(Multiset.new(1..10))
+    expect(ret).to be_nil
+    expect(set).to eql(Multiset.new(1..10))
 
     ret = set.reject! { |i| i % 3 == 0 }
-    set.should equal(ret)
-    set.should eql(Multiset[1, 2, 4, 5, 7, 8, 10])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 4, 5, 7, 8, 10])
   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, 6])
-    set.should equal(ret)
-    set.should eql(Multiset[1, 2, 2, 3, 4, 6])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 2, 2, 3, 4, 6])
   end
 
   it "should delete every element that appears in the given enumerable object and return self" do
     set = Multiset[1, 2, 3]
 
     ret = set.subtract([2, 4, 6])
-    set.should equal(ret)
-    set.should eql(Multiset[1, 3])
+    expect(set).to equal(ret)
+    expect(set).to eql(Multiset[1, 3])
   end
 
   it "should return a new set built by merging the set and the elements of the given enumerable object" do
     set = Multiset[1, 2, 3]
 
     ret = set + [2, 4, 6]
-    set.should_not equal(ret)
-    ret.should eql(Multiset[1, 2, 2, 3, 4, 6])
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 2, 2, 3, 4, 6])
   end
 
   it "should return a new set built by duplicating the set, removing every element that appears in the given enumerable object" do
     set = Multiset[1, 2, 3]
 
     ret = set - [2, 4, 6]
-    set.should_not equal(ret)
-    ret.should eql(Multiset[1, 3])
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[1, 3])
   end
 
   it "should return a new set containing elements common to the set and the given enumerable object" do
     set = Multiset[1, 2, 3, 4]
 
     ret = set & [2, 4, 6]
-    set.should_not equal(ret)
-    ret.should eql(Multiset[2, 4])
+    expect(set).to_not equal(ret)
+    expect(ret).to eql(Multiset[2, 4])
   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]
     ret = set ^ [2, 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
 end
 
@@ -271,31 +271,31 @@ shared_examples_for Set, "with inital values [1, 2]" do
   it "should add element to set" do
     @set.add("foo")
 
-    @set.include?(1).should be_true
-    @set.include?(2).should be_true
-    @set.include?("foo").should be_true
+    expect(@set.include?(1)).to be_true
+    expect(@set.include?(2)).to be_true
+    expect(@set.include?("foo")).to be_true
   end
 
   it "should merge elements into the set" do
     @set.merge([2, 6])
 
-    @set.include?(1).should be_true
-    @set.include?(2).should be_true
-    @set.include?(2).should be_true
-    @set.include?(6).should be_true
+    expect(@set.include?(1)).to be_true
+    expect(@set.include?(2)).to be_true
+    expect(@set.include?(2)).to be_true
+    expect(@set.include?(6)).to be_true
   end
 
   it "should iterate over all the values in the set" do
     a = []
     @set.each { |o| a << o }
-    a.should eql([1, 2])
+    expect(a).to eql([1, 2])
   end
 
   it "should convert to an array" do
-    @set.to_a.should eql([1, 2])
+    expect(@set.to_a).to eql([1, 2])
   end
 
   it "should convert to a set" do
-    @set.to_set.to_a.should eql([1, 2])
+    expect(@set.to_set.to_a).to eql([1, 2])
   end
 end

data/lib/multimap/spec/spec_helper.rb

@@ -11,11 +11,11 @@ Spec::Matchers.define :sorted_eql do |expected|
   if defined? Rubinius
     sorter = lambda { |a, b| a.hash <=> b.hash }
     match do |actual|
-      actual.sort(&sorter).should eql(expected.sort(&sorter))
+      expect(actual.sort(&sorter)).to eql(expected.sort(&sorter))
     end
   else
     match do |actual|
-      actual.should eql(expected)
+      expect(actual).to eql(expected)
     end
   end
 end

data/mailgun.gemspec

@@ -12,11 +12,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.name          = "mailgun"
   gem.require_paths = ["lib"]
-  gem.version       = "0.8"
-  
-  gem.add_dependency(%q<rest-client>, [">= 0"])  
+  gem.version       = "0.11"
 
   gem.add_development_dependency(%q<rspec>, [">= 2"])
-  gem.add_development_dependency(%q<debugger>, [">= 0"])
-  gem.add_development_dependency(%q<vcr>, [">= 0"])
+  gem.add_development_dependency(%q<pry>, [">= 0"])
+  gem.add_development_dependency(%q<webmock>, [">= 2"])
 end

data/spec/address_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Mailgun::Address do
+
+  before :each do
+    @sample = "foo@mailgun.net"
+  end
+
+  describe "validate an address" do
+    it "should require a public api key" do
+      mailgun = Mailgun({:api_key => "api-key"})
+      expect { mailgun.addresses }.to raise_error(ArgumentError, ":public_api_key is a required argument to validate addresses")
+    end
+    it "should make a GET request with correct params to find a given webhook" do
+      mailgun = Mailgun({:api_key => "api-key", :public_api_key => "public-api-key"})
+
+      sample_response = "{\"is_valid\":true,\"address\":\"foo@mailgun.net\",\"parts\":{\"display_name\":null,\"local_part\":\"foo\",\"domain\":\"mailgun.net\"},\"did_you_mean\":null}"
+      validate_url = mailgun.addresses.send(:address_url, 'validate')
+
+      expect(Mailgun).to receive(:submit).
+        with(:get, validate_url, {:address => @sample}).
+        and_return(sample_response)
+
+      mailgun.addresses.validate(@sample)
+    end
+  end
+end