pulse_meter_core 0.5.3 → 0.5.4

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZTU4NjA3YjM4ZTZiZGQ2NmI1N2RlNTEzMmE3ZDIxZjQ1YzAyN2E0ZA==
-  data.tar.gz: !binary |-
-    NDZkMjhlYjY1MTdmNTk3YjViYmUwMWYyZDJiMTAxZTZhNGJmNDFkYQ==
+SHA1:
+  metadata.gz: a0c168d18d028e8af421aaf61caf93b6a9dd967b
+  data.tar.gz: 146d72d603274caef865142f361de8160498c46a
 SHA512:
-  metadata.gz: !binary |-
-    YmJmYzI0YjZiNzIyNTMzODA2MjNjMjU5MjYyNjRiZGNmMGI1ODU5ZTc0OGNi
-    NDQzODkyZDliM2JjMmM4MmYyZGQ1MjlmY2UyNzRjZWVmNDU3NjI4NGZiNTdj
-    ZDAzMzliZjMyNzJjNTNjMDNhOTNjYTYwODk0MzQwMmNmNDI2YWY=
-  data.tar.gz: !binary |-
-    N2IyNTFlYjk3OTMyMjMwODNhMTIyOGNiYjU1MzQxOWU1NGViMTY0ZDA3OGI0
-    MjA1MjcyNDg1NTU3MDQ1OGMwOTdmMGRjNGM3NjU0MjllNzE3ZWUzNzdhNDlm
-    ZmVmNGE4OWNjNGQ2OTJlZmQxODU4NjFkYmQyM2Q3YzYxOTVkYmQ=
+  metadata.gz: 254f9d4029bdf4cdadb305331d77ac94896ec001a82778641560b123306ed510c408dc0917fecf696abb2b93f1f250bf454ce75381ee859916ee4da7e179507f
+  data.tar.gz: cc58c3a1180ebfcb10919b7dc49547e2daed741eef0daf4948482e7068ed9e2f427c4fb776950e57eb4d2338078acc00034e778730f957e1dc5a054b7fc90282

data/.rbenv-version

@@ -1 +1 @@
-1.9.3-p125
+2.2.2

data/.travis.yml

@@ -2,6 +2,8 @@ language: ruby
 rvm:
   - 1.9.2
   - 1.9.3
+  - 2.1.6
+  - 2.2.2
 branches:
   only:
     - master

data/pulse_meter_core.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "pulse_meter_core"
   gem.require_paths = ["lib"]
-  gem.version       = "0.5.3"
+  gem.version       = "0.5.4"
 
   gem.add_runtime_dependency('json')
   gem.add_runtime_dependency('redis')

data/spec/pulse_meter/command_aggregator/async_spec.rb

@@ -5,48 +5,48 @@ describe PulseMeter::CommandAggregator::Async do
   let(:redis){PulseMeter.redis}
 
   describe "#multi" do
-    it "should accumulate redis command and execute in a bulk" do
+    it "accumulates redis command and execute in a bulk" do
       ca.multi do
         ca.set("xxxx", "zzzz")
         ca.set("yyyy", "zzzz")
         sleep 0.1
-        redis.get("xxxx").should be_nil
-        redis.get("yyyy").should be_nil
+        expect(redis.get("xxxx")).to be_nil
+        expect(redis.get("yyyy")).to be_nil
       end
       ca.wait_for_pending_events
-      redis.get("xxxx").should == "zzzz"
-      redis.get("yyyy").should == "zzzz"
+      expect(redis.get("xxxx")).to eq("zzzz")
+      expect(redis.get("yyyy")).to eq("zzzz")
     end
   end
 
   describe "any other redis instance method" do
-    it "should be delegated to redis" do
+    it "is delegated to redis" do
       ca.set("xxxx", "zzzz")
       ca.wait_for_pending_events
-      redis.get("xxxx").should == "zzzz"
+      expect(redis.get("xxxx")).to eq("zzzz")
     end
 
-    it "should be aggregated if queue is not overflooded" do
+    it "is aggregated if queue is not overflooded" do
       redis.set("x", 0)
       ca.max_queue_length.times{ ca.incr("x") }
       ca.wait_for_pending_events
-      redis.get("x").to_i.should == ca.max_queue_length
+      expect(redis.get("x").to_i).to eq(ca.max_queue_length)
     end
 
-    it "should not be aggregated if queue is overflooded" do
+    it "is not aggregated if queue is overflooded" do
       redis.set("x", 0)
       (ca.max_queue_length * 2).times{ ca.incr("x") }
       ca.wait_for_pending_events
-      redis.get("x").to_i.should < 2 * ca.max_queue_length
+      expect(redis.get("x").to_i).to be < 2 * ca.max_queue_length
     end
   end
 
   describe "#wait_for_pending_events" do
-    it "should pause execution until aggregator thread sends all commands ro redis" do
+    it "pauses execution until aggregator thread sends all commands ro redis" do
       ca.set("xxxx", "zzzz")
-      redis.get("xxxx").should be_nil
+      expect(redis.get("xxxx")).to be_nil
       ca.wait_for_pending_events
-      redis.get("xxxx").should == "zzzz"
+      expect(redis.get("xxxx")).to eq("zzzz")
     end
   end
 

data/spec/pulse_meter/command_aggregator/sync_spec.rb

@@ -5,20 +5,20 @@ describe PulseMeter::CommandAggregator::Sync do
   let(:redis){PulseMeter.redis}
 
   describe "#multi" do
-    it "should accumulate redis command and execute in a bulk" do
+    it "accumulates redis command and execute in a bulk" do
       ca.multi do
         ca.set("xxxx", "zzzz")
         ca.set("yyyy", "zzzz")
       end
-      redis.get("xxxx").should == "zzzz"
-      redis.get("yyyy").should == "zzzz"
+      expect(redis.get("xxxx")).to eq("zzzz")
+      expect(redis.get("yyyy")).to eq("zzzz")
     end
   end
 
   describe "any other redis instance method" do
-    it "should be delegated to redis" do
+    it "is delegated to redis" do
       ca.set("xxxx", "zzzz")
-      redis.get("xxxx").should == "zzzz"
+      expect(redis.get("xxxx")).to eq("zzzz")
     end
   end
 end

data/spec/pulse_meter/command_aggregator/udp_spec.rb

@@ -5,26 +5,26 @@ describe PulseMeter::CommandAggregator::UDP do
   let(:port){33333}
   let(:udp_sock){double(:socket)}
   before do
-    UDPSocket.stub(:new).and_return(udp_sock)
-    udp_sock.stub(:fcntl).and_return(nil)
+    allow(UDPSocket).to receive(:new).and_return(udp_sock)
+    allow(udp_sock).to receive(:fcntl).and_return(nil)
     @ca = described_class.new([[host, port]])
   end
 
   describe "#multi" do
-    it "should accumulate redis commands and send them in a bulk" do
+    it "accumulates redis commands and send them in a bulk" do
       data = [
         ["set", "xxxx", "zzzz"],
         ["set", "yyyy", "zzzz"]
       ].to_json
-      udp_sock.should_receive(:send).with(data, 0, host, port).and_return(0)
+      expect(udp_sock).to receive(:send).with(data, 0, host, port).and_return(0)
       @ca.multi do
         @ca.set("xxxx", "zzzz")
         @ca.set("yyyy", "zzzz")
       end
     end
 
-    it "should ignore standard exceptions" do
-      udp_sock.should_receive(:send).and_raise(StandardError)
+    it "ignores standard exceptions" do
+      expect(udp_sock).to receive(:send).and_raise(StandardError)
       @ca.multi do
         @ca.set("xxxx", "zzzz")
       end
@@ -32,11 +32,11 @@ describe PulseMeter::CommandAggregator::UDP do
   end
 
   describe "any other redis instance method" do
-    it "should send data imediately" do
+    it "sends data imediately" do
       data = [
         ["set", "xxxx", "zzzz"]
       ].to_json
-      udp_sock.should_receive(:send).with(data, 0, host, port).and_return(0)
+      expect(udp_sock).to receive(:send).with(data, 0, host, port).and_return(0)
       @ca.set("xxxx", "zzzz")
     end
   end

data/spec/pulse_meter/mixins/dumper_spec.rb

@@ -30,21 +30,21 @@ describe PulseMeter::Mixins::Dumper do
   describe '#dump' do
     context "when class violates dump contract" do
       context "when it has no name attribute" do
-        it "should raise exception" do
+        it "raises exception" do
           def bad_obj.redis; PulseMeter.redis; end
           expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
         end
       end
 
       context "when it has no redis attribute" do
-        it "should raise exception" do
+        it "raises exception" do
           def bad_obj.name; :foo; end
           expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
         end
       end
 
       context "when redis is not avalable" do
-        it "should raise exception" do
+        it "raises exception" do
           def bad_obj.name; :foo; end
           def bad_obj.redis; nil; end
           expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
@@ -53,25 +53,25 @@ describe PulseMeter::Mixins::Dumper do
     end
 
     context "when class follows dump contract" do
-      it "should not raise dump exception" do
+      it "does not raise dump exception" do
         expect {good_obj.dump!}.not_to raise_exception
       end
 
-      it "should save dump to redis" do
+      it "saves dump to redis" do
         expect {good_obj.dump!}.to change {redis.hlen(Good::DUMP_REDIS_KEY)}.by(1)
       end
     end
 
     context "when dump is safe" do
-      it "should not overwrite stored objects of the same type" do
+      it "does not overwrite stored objects of the same type" do
         good_obj.some_value = 123
         good_obj.dump!
         good_obj.some_value = 321
         good_obj.dump!
-        Base.restore(good_obj.name).some_value.should == 123
+        expect(Base.restore(good_obj.name).some_value).to eq(123)
       end
 
-      it "should raise DumpConflictError exception if sensor with the same name but different type already exists" do
+      it "raises DumpConflictError exception if sensor with the same name but different type already exists" do
         good_obj.name = "duplicate_name"
         good_obj_of_another_type.name = "duplicate_name"
         good_obj.dump!
@@ -82,7 +82,7 @@ describe PulseMeter::Mixins::Dumper do
 
   describe ".restore" do
     context "when object has never been dumped" do
-      it "should raise exception" do
+      it "raises exception" do
         expect{ Base.restore(:nonexistant) }.to raise_exception(PulseMeter::RestoreError)
       end
     end
@@ -92,20 +92,20 @@ describe PulseMeter::Mixins::Dumper do
         good_obj.dump!
       end
 
-      it "should keep object class" do
-        Base.restore(good_obj.name).should be_instance_of(good_obj.class)
+      it "keeps object class" do
+        expect(Base.restore(good_obj.name)).to be_instance_of(good_obj.class)
       end
 
-      it "should restore object data" do
+      it "restores object data" do
         restored = Base.restore(good_obj.name)
-        restored.some_value.should == good_obj.some_value
+        expect(restored.some_value).to eq(good_obj.some_value)
       end
 
-      it "should restore last dumped object" do
+      it "restores last dumped object" do
         good_obj.some_value = :bar
         good_obj.dump!(false)
         restored = Base.restore(good_obj.name)
-        restored.some_value.should == :bar
+        expect(restored.some_value).to eq(:bar)
       end
     end
   end
@@ -113,23 +113,23 @@ describe PulseMeter::Mixins::Dumper do
   describe ".list_names" do
     context "when redis is not available" do
       before do
-        PulseMeter.stub(:redis).and_return(nil)
+        allow(PulseMeter).to receive(:redis).and_return(nil)
       end
 
-      it "should raise exception" do
+      it "raises exception" do
         expect {Base.list_names}.to raise_exception(PulseMeter::RestoreError)
       end
     end
 
     context "when redis if fine" do
-      it "should return empty list if nothing is registered" do
-        Base.list_names.should == []
+      it "returns empty list if nothing is registered" do
+        expect(Base.list_names).to eq([])
       end
 
-      it "should return list of registered objects" do
+      it "returns list of registered objects" do
         good_obj.dump!(false)
         another_good_obj.dump!(false)
-        Base.list_names.should =~ [good_obj.name, another_good_obj.name]
+        expect(Base.list_names).to match_array([good_obj.name, another_good_obj.name])
       end
     end
   end
@@ -140,20 +140,20 @@ describe PulseMeter::Mixins::Dumper do
       another_good_obj.dump!
     end
 
-    it "should return restored objects" do
+    it "returns restored objects" do
       objects = Base.list_objects
-      objects.map(&:name).should =~ [good_obj.name, another_good_obj.name]
+      expect(objects.map(&:name)).to match_array([good_obj.name, another_good_obj.name])
     end
 
-    it "should skip unrestorable objects" do
-      Base.stub(:list_names).and_return([good_obj.name, "scoundrel", another_good_obj.name])
+    it "skips unrestorable objects" do
+      allow(Base).to receive(:list_names).and_return([good_obj.name, "scoundrel", another_good_obj.name])
       objects = Base.list_objects
-      objects.map(&:name).should =~ [good_obj.name, another_good_obj.name]
+      expect(objects.map(&:name)).to match_array([good_obj.name, another_good_obj.name])
     end
   end
 
   describe "#cleanup_dump" do
-    it "should remove data from redis" do
+    it "removes data from redis" do
       good_obj.dump!
       another_good_obj.dump!
       expect {good_obj.cleanup_dump}.to change{good_obj.class.list_names.count}.by(-1)

data/spec/pulse_meter/mixins/utils_spec.rb

@@ -9,63 +9,63 @@ describe PulseMeter::Mixins::Utils do
 
   describe '#constantize' do
     context "when argument is a string with a valid class name" do
-      it "should return class" do
-        dummy.constantize("PulseMeter::Mixins::Utils").should == PulseMeter::Mixins::Utils
+      it "returns class" do
+        expect(dummy.constantize("PulseMeter::Mixins::Utils")).to eq(PulseMeter::Mixins::Utils)
       end
     end
     context "when argument is a string with invalid class name" do
-      it "should return nil" do
-        dummy.constantize("Pumpkin::Eater").should be_nil
+      it "returns nil" do
+        expect(dummy.constantize("Pumpkin::Eater")).to be_nil
       end
     end
     context "when argument is not a string" do
-      it "should return nil" do
-        dummy.constantize({}).should be_nil
+      it "returns nil" do
+        expect(dummy.constantize({})).to be_nil
       end
     end
   end
 
   describe "#assert_positive_integer!" do
-    it "should extract integer value from hash by passed key" do
-      dummy.assert_positive_integer!({:val => 4}, :val).should == 4
+    it "extracts integer value from hash by passed key" do
+      expect(dummy.assert_positive_integer!({:val => 4}, :val)).to eq(4)
     end
 
     context "when no default value given" do
       context "when the value by the passed key is not integer" do
-        it "should convert non-integers to integers" do
-          dummy.assert_positive_integer!({:val => 4.4}, :val).should == 4
+        it "converts non-integers to integers" do
+          expect(dummy.assert_positive_integer!({:val => 4.4}, :val)).to eq(4)
         end
 
-        it "should change the original value to the obtained integer" do
+        it "changes the original value to the obtained integer" do
           h = {:val => 4.4}
-          dummy.assert_positive_integer!(h, :val).should == 4
-          h[:val].should == 4
+          expect(dummy.assert_positive_integer!(h, :val)).to eq(4)
+          expect(h[:val]).to eq(4)
         end
 
-        it "should raise exception if the original value cannot be converted to integer"do
+        it "raises exception if the original value cannot be converted to integer"do
           expect{ dummy.assert_positive_integer!({:val => :bad_int}, :val) }.to raise_exception(ArgumentError)
         end
       end
 
-      it "should raise exception if the value is not positive" do
+      it "raises exception if the value is not positive" do
         expect{ dummy.assert_positive_integer!({:val => -1}, :val) }.to raise_exception(ArgumentError)
       end
 
-      it "should raise exception if the value is not defined" do
+      it "raises exception if the value is not defined" do
         expect{ dummy.assert_positive_integer!({}, :val) }.to raise_exception(ArgumentError)
       end
     end
 
     context "when default value given" do
-      it "should prefer value from options to default" do
-        dummy.assert_positive_integer!({:val => 4}, :val, 22).should == 4
+      it "prefers value from options to default" do
+        expect(dummy.assert_positive_integer!({:val => 4}, :val, 22)).to eq(4)
       end
 
-      it "should use default value when there is no one in options" do
-        dummy.assert_positive_integer!({}, :val, 22).should == 22
+      it "uses default value when there is no one in options" do
+        expect(dummy.assert_positive_integer!({}, :val, 22)).to eq(22)
       end
 
-      it "should check default value if it is to be used" do
+      it "checks default value if it is to be used" do
         expect{dummy.assert_positive_integer!({}, :val, :bad)}.to raise_exception(ArgumentError)
         expect{dummy.assert_positive_integer!({}, :val, -1)}.to raise_exception(ArgumentError)
       end
@@ -73,30 +73,30 @@ describe PulseMeter::Mixins::Utils do
   end
 
   describe "#assert_array!" do
-    it "should extract value from hash by passed key" do
-      dummy.assert_array!({:val => [:foo]}, :val).should == [:foo]
+    it "extracts value from hash by passed key" do
+      expect(dummy.assert_array!({:val => [:foo]}, :val)).to eq([:foo])
     end
 
     context "when no default value given" do
-      it "should raise exception if th value is not an Array" do
+      it "raises exception if th value is not an Array" do
         expect{ dummy.assert_array!({:val => :bad}, :val) }.to raise_exception(ArgumentError)
       end
 
-      it "should raise exception if the value is not defined" do
+      it "raises exception if the value is not defined" do
         expect{ dummy.assert_array!({}, :val) }.to raise_exception(ArgumentError)
       end
     end
 
     context "when default value given" do
-      it "should prefer value from options to default" do
-        dummy.assert_array!({:val => [:foo]}, :val, []).should == [:foo]
+      it "prefers value from options to default" do
+        expect(dummy.assert_array!({:val => [:foo]}, :val, [])).to eq([:foo])
       end
 
-      it "should use default value when there is no one in options" do
-        dummy.assert_array!({}, :val, []).should == []
+      it "uses default value when there is no one in options" do
+        expect(dummy.assert_array!({}, :val, [])).to eq([])
       end
 
-      it "should check default value if it is to be used" do
+      it "checks default value if it is to be used" do
         expect{dummy.assert_array!({}, :val, :bad)}.to raise_exception(ArgumentError)
       end
     end
@@ -104,81 +104,81 @@ describe PulseMeter::Mixins::Utils do
 
   describe "#assert_ranged_float!" do
 
-    it "should extract float value from hash by passed key" do
-      dummy.assert_ranged_float!({:val => 4}, :val, 0, 100).should be_generally_equal(4)
+    it "extracts float value from hash by passed key" do
+      expect(dummy.assert_ranged_float!({:val => 4}, :val, 0, 100)).to be_generally_equal(4)
     end
 
     context "when the value by the passed key is not float" do
-      it "should convert non-floats to floats" do
-        dummy.assert_ranged_float!({:val => "4.0000"}, :val, 0, 100).should be_generally_equal(4)
+      it "converts non-floats to floats" do
+        expect(dummy.assert_ranged_float!({:val => "4.0000"}, :val, 0, 100)).to be_generally_equal(4)
       end
 
-      it "should change the original value to the obtained float" do
+      it "changes the original value to the obtained float" do
         h = {:val => "4.000"}
-        dummy.assert_ranged_float!(h, :val, 0, 100).should be_generally_equal(4)
-        h[:val].should be_generally_equal(4)
+        expect(dummy.assert_ranged_float!(h, :val, 0, 100)).to be_generally_equal(4)
+        expect(h[:val]).to be_generally_equal(4)
       end
 
-      it "should raise exception if the original value cannot be converted to float" do
+      it "raises exception if the original value cannot be converted to float" do
         expect{ dummy.assert_ranged_float!({:val => :bad_float}, :val, 0, 100) }.to raise_exception(ArgumentError)
       end
     end
 
-    it "should raise exception if the value is not within range" do
+    it "raises exception if the value is not within range" do
       expect{ dummy.assert_ranged_float!({:val => -0.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
       expect{ dummy.assert_ranged_float!({:val => 100.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
     end
 
-    it "should raise exception if the value is not defined" do
+    it "raises exception if the value is not defined" do
       expect{ dummy.assert_ranged_float!({}, :val) }.to raise_exception(ArgumentError)
     end
   end
 
   describe "#uniqid" do
-    it "should return uniq strings" do
+    it "returns uniq strings" do
       uniq_values = (1..1000).map{|_| dummy.uniqid}
-      uniq_values.uniq.count.should == uniq_values.count
+      expect(uniq_values.uniq.count).to eq(uniq_values.count)
     end
   end
 
   describe "#titleize" do
-    it "should convert identificator to title" do
-      dummy.titleize("aaa_bbb").should == 'Aaa Bbb'
-      dummy.titleize(:aaa_bbb).should == 'Aaa Bbb'
-      dummy.titleize("aaa bbb").should == 'Aaa Bbb'
+    it "converts identificator to title" do
+      expect(dummy.titleize("aaa_bbb")).to eq('Aaa Bbb')
+      expect(dummy.titleize(:aaa_bbb)).to eq('Aaa Bbb')
+      expect(dummy.titleize("aaa bbb")).to eq('Aaa Bbb')
     end
   end
 
   describe "#camelize" do
-    it "should camelize string" do
-      dummy.camelize("aa_bb_cc").should == "aaBbCc"
-      dummy.camelize("aa_bb_cc", true).should == "AaBbCc"
+    it "camelizes string" do
+      expect(dummy.camelize("aa_bb_cc")).to eq("aaBbCc")
+      expect(dummy.camelize("aa_bb_cc", true)).to eq("AaBbCc")
     end
   end
 
   describe "#underscore" do
-    it "should underscore string" do
-      dummy.underscore("aaBbCc").should == "aa_bb_cc"
-      dummy.underscore("AaBbCc").should == "aa_bb_cc"
-      dummy.underscore("aaBb::Cc").should == "aa_bb/cc"
+    it "underscores string" do
+      expect(dummy.underscore("aaBbCc")).to eq("aa_bb_cc")
+      expect(dummy.underscore("AaBbCc")).to eq("aa_bb_cc")
+      expect(dummy.underscore("aaBb::Cc")).to eq("aa_bb/cc")
     end
   end
 
   describe "#camelize_keys" do
-    it "should deeply camelize keys in hashes" do
-      dummy.camelize_keys({ :aa_bb_cc => [ { :dd_ee => 123 }, 456 ] }).should =={ 'aaBbCc' => [ { 'ddEe' => 123 }, 456 ] }
+    it "deeply camelizes keys in hashes" do
+      expect(dummy.camelize_keys({ :aa_bb_cc => [ { :dd_ee => 123 }, 456 ] })).to eq({ 'aaBbCc' => [ { 'ddEe' => 123 }, 456 ] })
     end
   end
 
   describe "#symbolize_keys" do
-    it "should convert symbolizable keys to symbols" do
-      dummy.symbolize_keys({"a" => 5, 6 => 7}).should == {a: 5, 6 => 7}
+    it "converts symbolizable keys to symbols" do
+      expect(dummy.symbolize_keys({"a" => 5, 6 => 7})).to eq({a: 5, 6 => 7})
     end
   end
 
   describe "#subsets_of" do
     it "returns all subsets of given array" do
-      dummy.subsets_of([1, 2]).sort.should == [[], [1], [2], [1, 2]].sort
+      expect(dummy.subsets_of([1, 2]).sort).to eq([[], [1], [2], [1, 2]].sort)
     end
   end
 
@@ -186,25 +186,25 @@ describe PulseMeter::Mixins::Utils do
     it "iterates over each subset" do
       subsets = []
       dummy.each_subset([1, 2]) {|s| subsets << s}
-      subsets.sort.should == [[], [1], [2], [1, 2]].sort
+      expect(subsets.sort).to eq([[], [1], [2], [1, 2]].sort)
     end
   end
 
   describe '#parse_time' do
     context "when argument is a valid YYYYmmddHHMMSS string" do
-      it "should correct Time object" do
+      it "corrects Time object" do
         t = dummy.parse_time("19700101000000")
-        t.should be_kind_of(Time)
-        t.to_i.should == 0
+        expect(t).to be_kind_of(Time)
+        expect(t.to_i).to eq(0)
       end
     end
     context "when argument is an invalid YYYYmmddHHMMSS string" do
-      it "should raise ArgumentError" do
+      it "raises ArgumentError" do
         expect{ dummy.parse_time("19709901000000") }.to raise_exception(ArgumentError)
       end
     end
     context "when argument is not a YYYYmmddHHMMSS string" do
-      it "should raise ArgumentError" do
+      it "raises ArgumentError" do
         expect{ dummy.parse_time("197099010000000") }.to raise_exception(ArgumentError)
       end
     end