reg.api2 0.0.12 → 0.0.14

data/spec/lib/reg_api2/service_spec.rb

@@ -12,72 +12,72 @@ describe RegApi2::Service do
         { service_id: "22bug22" },
         { surprise: "surprise.ru" }
       ])
-      ans.map do |rec|
+      expect(ans.map do |rec|
         rec.result == 'success' ? rec.dname : rec.error_code
-      end.sort.should == %w[ INVALID_SERVICE_ID NO_DOMAIN test.ru test.su test12347.ru ]
+      end.sort).to eq(%w[ INVALID_SERVICE_ID NO_DOMAIN test.ru test.su test12347.ru ])
     end
   end
 
   describe :get_prices do
     it "should return prices" do
       ans = service.get_prices show_renew_data: true
-      ans.should have_key :prices
+      expect(ans).to have_key :prices
     end
   end
 
   describe :get_servtype_details do
     it "should return service type details" do
       ans = service.get_servtype_details servtype: :srv_hosting_ispmgr
-      ans.first.should have_key :commonname
+      expect(ans.first).to have_key :commonname
     end
   end
 
   describe :create do
     it "should create srv_hosting_ispmgr service" do
       ans = service.create dname: 'qqq.ru', servtype: :srv_hosting_ispmgr, period: 1, plan: 'Host-2-1209'
-      ans.descr.should =~ /srv_hosting_ispmgr.+ordered/
+      expect(ans.descr).to match(/srv_hosting_ispmgr.+ordered/)
     end
   end
 
   describe :delete do
     it "should remove srv_hosting_ispmgr service" do
       ans = service.delete domain_name: 'test.ru', servtype: :srv_hosting_ispmgr
-      ans.should be_nil
+      expect(ans).to be_nil
     end
   end
 
   describe :get_list do
     it "should get list of domains" do
       ans = service.get_list servtype: :domain
-      ans.should be_kind_of Array
-      ans.map(&:servtype).uniq.should == [ "domain"]
-      ans.map(&:service_id).each { |id| id.should be_kind_of Fixnum }
+      expect(ans).to be_kind_of Array
+      expect(ans.map(&:servtype).uniq).to eq([ "domain"])
+      ans.map(&:service_id).each { |id| expect(id).to be_kind_of Fixnum }
     end
   end
 
   describe :get_dedicated_server_list do
     it "should get list of dedicated servers" do
       ans = service.get_dedicated_server_list
-      ans.should be_kind_of Array
-      ans.map(&:server_id).each { |id| id.should be_kind_of Fixnum }
+      expect(ans).to be_kind_of Array
+      ans.map(&:server_id).each { |id| expect(id).to be_kind_of Fixnum }
     end
   end
 
   describe :get_bills do
     it "should get list of services and bills" do
       ans = service.get_bills dname: "qqq.ru"
-      ans.services.should be_kind_of Array
-      ans.bills.should be_nil
+      expect(ans.services).to be_kind_of Array
+      expect(ans.bills).to be_nil
     end
   end
 
   describe :refill do
     it "should refill by service id" do
       ans = service.refill service_id: 123456, amount: 10, currency: 'UAH'
-      ans.pay_notes.should include("success")
-      ans.pay_type.should == "prepay"
-      ans.service_id.should == 123456
-      ans.payment.should > 0
+      expect(ans.pay_notes).to include("success")
+      expect(ans.pay_type).to eq("prepay")
+      expect(ans.service_id).to eq(123456)
+      expect(ans.payment).to be > 0
     end
   end
 end

data/spec/lib/reg_api2/shop_spec.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+describe RegApi2::Shop do
+
+  include RegApi2
+
+  describe :nop do
+    it "should raise nothing" do
+      expect { shop.nop }.not_to raise_error
+    end
+
+    it "should return lot id if domain exist" do
+      expect(RegApi2.shop.nop(dname: 'test.ru')).to have_key( 'lot_id' )
+    end
+  end
+end

data/spec/lib/reg_api2/sym_hash_spec.rb

@@ -6,76 +6,76 @@ describe RegApi2::SymHash do
 
   describe :new do
     it "should be kind of Hash" do
-      hash.should be_kind_of(Hash)
+      expect(hash).to be_kind_of(Hash)
     end
   end
 
   describe :method_missing do
     it "should assign key" do
       hash.unique_key = "unique"
-      hash["unique_key"].should == "unique"
+      expect(hash["unique_key"]).to eq("unique")
     end
 
     it "should reassign key" do
       hash["next_key"] = "a"
       hash.next_key = "b"
-      hash["next_key"].should == "b"
+      expect(hash["next_key"]).to eq("b")
     end
 
     it "should return value" do
       hash["another_key"] = "f"
-      hash.another_key.should == "f"
+      expect(hash.another_key).to eq("f")
     end
 
     it "should return bool if key ends with ?" do
       hash.ping = 15
-      hash.should be_ping
+      expect(hash).to be_ping
       hash.pong = nil
-      hash.should_not be_pong
+      expect(hash).not_to be_pong
     end
 
     it "should return nil unless keypair present" do
-      hash.absent_key.should be_nil
-    end 
+      expect(hash.absent_key).to be_nil
+    end
   end
 
   describe :respond_to? do
     it "should always respond to any method" do
-      hash.should respond_to(:any_method)
+      expect(hash).to respond_to(:any_method)
     end
   end
 
   describe :include? do
     it "should be has_key?" do
       allow(hash).to receive(:has_key?).with("what").and_return(true)
-      hash.include?("what").should be_true
+      expect(hash.include?("what")).to be true
     end
   end
 
   describe :has_key? do
     it "should represent symbol keys as strings" do
       hash["frank"] = 56
-      hash[:frank].should == 56
-      hash.should have_key("frank")
-      hash.should have_key(:frank)
+      expect(hash[:frank]).to eq(56)
+      expect(hash).to have_key("frank")
+      expect(hash).to have_key(:frank)
 
       hash[:bravo] = 56
-      hash["bravo"].should == 56
-      hash.should have_key("bravo")
-      hash.should have_key(:bravo)
+      expect(hash["bravo"]).to eq(56)
+      expect(hash).to have_key("bravo")
+      expect(hash).to have_key(:bravo)
     end
   end
 
   describe "self.from" do
     it "should deeply clone structures with replacing hashes with SymHash" do
       res = RegApi2::SymHash.from([{a: 1}, {b: 2}, [ 1, 2, 3 ]])
-      res.should be_kind_of(Array)
-      res.should have(3).elements
-      res.first.should be_kind_of(RegApi2::SymHash)
-      res[1].should be_kind_of(RegApi2::SymHash)
-      res.last.should_not be_kind_of(RegApi2::SymHash)
-      res.last.should be_kind_of(Array)
-      res.last.should == [ 1, 2 , 3 ]
+      expect(res).to be_kind_of(Array)
+      expect(res).to have_exactly(3).elements
+      expect(res.first).to be_kind_of(RegApi2::SymHash)
+      expect(res[1]).to be_kind_of(RegApi2::SymHash)
+      expect(res.last).not_to be_kind_of(RegApi2::SymHash)
+      expect(res.last).to be_kind_of(Array)
+      expect(res.last).to eq([ 1, 2 , 3 ])
     end
   end
 end

data/spec/lib/reg_api2/user_spec.rb

@@ -9,44 +9,44 @@ describe RegApi2::User do
 
   describe :nop do
     it "should raise nothing" do
-      lambda { user.nop }.should_not raise_error
+      expect { user.nop }.not_to raise_error
     end
     
     it "should return nil" do
-      user.nop.should be_nil
+      expect(user.nop).to be_nil
     end
   end
 
   describe :create do
     it "should raise ContractError unless user_login provided." do
-      lambda { user.create(FakeUser.make(:bad_login)) }.should raise_error RegApi2::ContractError
-      lambda { user.create(FakeUser.make(:bad_login)) }.should raise_error /user_login/
+      expect { user.create(FakeUser.make(:bad_login)) }.to raise_error RegApi2::ContractError
+      expect { user.create(FakeUser.make(:bad_login)) }.to raise_error /user_login/
     end
 
     it "should raise ContractError unless user_password provided." do
-      lambda { user.create(FakeUser.make(:bad_password)) }.should raise_error RegApi2::ContractError
-      lambda { user.create(FakeUser.make(:bad_password)) }.should raise_error /user_password/
+      expect { user.create(FakeUser.make(:bad_password)) }.to raise_error RegApi2::ContractError
+      expect { user.create(FakeUser.make(:bad_password)) }.to raise_error /user_password/
     end
 
     it "should raise ContractError unless user_email provided." do
-      lambda { user.create(FakeUser.make(:bad_email)) }.should raise_error RegApi2::ContractError
-      lambda { user.create(FakeUser.make(:bad_email)) }.should raise_error /user_email/
+      expect { user.create(FakeUser.make(:bad_email)) }.to raise_error RegApi2::ContractError
+      expect { user.create(FakeUser.make(:bad_email)) }.to raise_error /user_email/
     end
   
     it "should raise ContractError unless user_country_code provided." do
-      lambda { user.create(FakeUser.make(:bad_country_code)) }.should raise_error RegApi2::ContractError
-      lambda { user.create(FakeUser.make(:bad_country_code)) }.should raise_error /user_country_code/
+      expect { user.create(FakeUser.make(:bad_country_code)) }.to raise_error RegApi2::ContractError
+      expect { user.create(FakeUser.make(:bad_country_code)) }.to raise_error /user_country_code/
     end
 
     it "should create user with valid data." do
-      lambda { user.create(FakeUser.make(:good_user)) }.should_not raise_error
-      user.create(FakeUser.make(:good_user)).should == "777"
+      expect { user.create(FakeUser.make(:good_user)) }.not_to raise_error
+      expect(user.create(FakeUser.make(:good_user))).to eq("777")
     end
   end
 
   describe :get_statistics do
     it "should return user statistics" do
-      user.get_statistics.keys.sort.should == %w[
+      expect(user.get_statistics.keys.sort).to eq(%w[
         active_domains_cnt 
         active_domains_get_ctrl_cnt 
         balance_total 
@@ -54,16 +54,16 @@ describe RegApi2::User do
         renew_domains_cnt 
         renew_domains_get_ctrl_cnt 
         undelegated_domains_cnt 
-      ]
+      ])
     end
   end
 
   describe :get_balance do
     it "should return user balance" do
-      user.get_balance(currency: :USD).keys.sort.should == %w[
+      expect(user.get_balance(currency: :USD).keys.sort).to eq(%w[
         currency
         prepay
-      ]
+      ])
     end
   end
 
@@ -75,11 +75,11 @@ describe RegApi2::User do
         currency: :RUR,
         amount: 1000
       )
-      ans.currency.should == 'RUR'
-      ans.pay_type.should == 'WM'
-      ans.payment.should == 1000
-      ans.total_payment.should == 1000
-      ans.should have_key :wm_invid
+      expect(ans.currency).to eq('RUR')
+      expect(ans.pay_type).to eq('WM')
+      expect(ans.payment).to eq(1000)
+      expect(ans.total_payment).to eq(1000)
+      expect(ans).to have_key :wm_invid
     end
   end
 end

data/spec/lib/reg_api2/zone_spec.rb

@@ -8,13 +8,13 @@ describe RegApi2::Zone do
 
   describe :nop do
     it "should raise when no args" do
-      lambda { zone.nop }.should raise_error
+      expect { zone.nop }.to raise_error
     end
     
     it "should return domains if specified" do
       ans = zone.nop(domains: [ { dname: "test.ru" }, { dname: "test.com" } ])
-      ans.domains.map(&:servtype).should == [ 'domain', 'domain' ]
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:servtype)).to eq([ 'domain', 'domain' ])
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end  
   end
 
@@ -25,7 +25,7 @@ describe RegApi2::Zone do
         subdomain: '@',
         ipaddr: IPAddr.new("111.111.111.111")
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
 
     it "should understood ip addresses as strings too" do
@@ -34,7 +34,7 @@ describe RegApi2::Zone do
         subdomain: '*',
         ipaddr: "111.111.111.111"
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -45,7 +45,7 @@ describe RegApi2::Zone do
         subdomain: '@',
         ipaddr: IPAddr.new("aa11::a111:11aa:aaa1:aa1a")
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
 
     it "should understood ipv6 addresses as strings too" do
@@ -54,7 +54,7 @@ describe RegApi2::Zone do
         subdomain: '*',
         ipaddr: "aa11::a111:11aa:aaa1:aa1a"
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -65,7 +65,7 @@ describe RegApi2::Zone do
         subdomain: "mail",
         canonical_name: "mx10.test.ru"
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -76,7 +76,7 @@ describe RegApi2::Zone do
         subdomain: '@',
         mail_server: IPAddr.new("111.111.111.111")
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
 
     it "should understood mail servers as domains too" do
@@ -86,7 +86,7 @@ describe RegApi2::Zone do
         priority: 1,
         mail_server: "mail"
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -98,18 +98,18 @@ describe RegApi2::Zone do
         dns_server: "ns.test.ru",
         record_number: 10
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
 
     it "should check record number" do
-      lambda do
+      expect do
         zone.add_ns(
           domains: [ { dname: "test.ru" }, { dname: "test.com" } ],
           subdomain: 'tt',
           dns_server: "ns.test.ru",
           record_number: 'fg'
         )
-      end.should raise_error RegApi2::ContractError
+      end.to raise_error RegApi2::ContractError
     end
   end
 
@@ -120,7 +120,7 @@ describe RegApi2::Zone do
         subdomain: 'mail',
         text: "testmail"
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -133,7 +133,7 @@ describe RegApi2::Zone do
         port: 5060,
         target: "sip.test.ru"
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -142,8 +142,8 @@ describe RegApi2::Zone do
       ans = zone.get_resource_records(
         domains: [ { dname: "test.ru" }, { dname: "test.com" } ]
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
-      ans.domains.map(&:rrs).should be_kind_of(Array)
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
+      expect(ans.domains.map(&:rrs)).to be_kind_of(Array)
     end
   end
 
@@ -153,8 +153,8 @@ describe RegApi2::Zone do
         { action: :add_alias, subdomain: "www", ipaddr: "11.22.33.44" },
         { action: :add_cname, subdomain: "@", canonical_name: "www.test.ru" }
       ]
-      ans.domains.map(&:result).should == [ 'success' ]
-      ans.domains.first.action_list.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success' ])
+      expect(ans.domains.first.action_list.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -165,7 +165,7 @@ describe RegApi2::Zone do
         ttl: "1d",
         minimum_ttl: "4h"
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -174,7 +174,7 @@ describe RegApi2::Zone do
       ans = zone.tune_forwarding(
         domains: [ { dname: "test.ru" }, { dname: "test.com" } ],
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -183,7 +183,7 @@ describe RegApi2::Zone do
       ans = zone.clear_forwarding(
         domains: [ { dname: "test.ru" }, { dname: "test.com" } ],
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -192,7 +192,7 @@ describe RegApi2::Zone do
       ans = zone.tune_parking(
         domains: [ { dname: "test.ru" }, { dname: "test.com" } ],
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -201,7 +201,7 @@ describe RegApi2::Zone do
       ans = zone.clear_parking(
         domains: [ { dname: "test.ru" }, { dname: "test.com" } ],
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -213,7 +213,7 @@ describe RegApi2::Zone do
         content: '111.111.111.111', 
         record_type: :A
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 
@@ -222,7 +222,7 @@ describe RegApi2::Zone do
       ans = zone.clear(
         domains: [ { dname: "test.ru" }, { dname: "test.com" } ],
       )
-      ans.domains.map(&:result).should == [ 'success', 'success' ]
+      expect(ans.domains.map(&:result)).to eq([ 'success', 'success' ])
     end
   end
 end

data/spec/spec_helper.rb

@@ -15,6 +15,10 @@ end
 require 'faker'
 require 'machinist'
 require 'rspec/core'
+require 'rspec/collection_matchers'
+
+require 'i18n'
+I18n.enforce_available_locales = false
 
 require 'reg_api2'
 
@@ -23,7 +27,6 @@ class RegApi2::Entity::EntityBase
 end
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus