aemo 0.5.1 → 0.6.0

data/spec/lib/aemo/nmi_spec.rb

@@ -10,12 +10,13 @@ describe AEMO::NMI do
   # CLASS CONSTANTS
   # ---
   describe '::TNI_CODES' do
-    it 'should be a hash' do
+    it 'is a hash' do
       expect(AEMO::NMI::TNI_CODES.class).to eq(Hash)
     end
   end
+
   describe '::DLF_CODES' do
-    it 'should be a hash' do
+    it 'is a hash' do
       expect(AEMO::NMI::DLF_CODES.class).to eq(Hash)
     end
   end
@@ -25,52 +26,57 @@ describe AEMO::NMI do
   # ---
   describe '.valid_nmi?(nmi)' do
     context 'valid' do
-      it 'should validate nmi' do
+      it 'validates nmi' do
         json.each do |nmi|
-          expect(AEMO::NMI.valid_nmi?(nmi['nmi'])).to eq(true)
+          expect(described_class.valid_nmi?(nmi['nmi'])).to be(true)
         end
       end
     end
+
     context 'invalid' do
-      it 'should invalidate' do
-        expect(AEMO::NMI.valid_nmi?('OOOOOOOOOO')).to eq(false)
+      it 'invalidates' do
+        expect(described_class.valid_nmi?('OOOOOOOOOO')).to be(false)
       end
-      it 'should invalidate' do
-        expect(AEMO::NMI.valid_nmi?('NM100')).to eq(false)
+
+      it 'invalidates' do
+        expect(described_class.valid_nmi?('NM100')).to be(false)
       end
-      it 'should invalidate' do
-        expect { AEMO::NMI.valid_nmi? }.to raise_error(ArgumentError)
+
+      it 'invalidates' do
+        expect { described_class.valid_nmi? }.to raise_error(ArgumentError)
       end
     end
   end
 
   describe '.valid_checksum?(nmi, checksum)' do
-    it 'should validate valid nmi and checksums' do
+    it 'validates valid nmi and checksums' do
       json.each do |nmi|
-        expect(AEMO::NMI.valid_checksum?(nmi['nmi'], nmi['checksum'])).to eq(true)
+        expect(described_class.valid_checksum?(nmi['nmi'], nmi['checksum'])).to be(true)
       end
     end
   end
 
   describe '.network(nmi)' do
-    it 'should return a network for an allocated NMI' do
-      network = AEMO::NMI.network('NCCCC00000')
+    it 'returns a network for an allocated NMI' do
+      network = described_class.network('NCCCC00000')
       expect(network.title).to eq('Ausgrid')
     end
-    it 'should return NIL for an unallocated NMI' do
-      network = AEMO::NMI.network('ZZZZZZZZZZZZ')
-      expect(network).to eq(nil)
+
+    it 'returns NIL for an unallocated NMI' do
+      network = described_class.network('ZZZZZZZZZZZZ')
+      expect(network).to be_nil
     end
   end
 
   describe '.allocation(nmi)' do
-    it 'should return an Allocation for a NMI' do
-      allocation = AEMO::NMI.allocation('NCCCC00000')
+    it 'returns an Allocation for a NMI' do
+      allocation = described_class.allocation('NCCCC00000')
       expect(allocation.title).to eq('Ausgrid')
     end
-    it 'should return NIL for an unallocated NMI' do
-      allocation = AEMO::NMI.allocation('ZZZZZZZZZZZZ')
-      expect(allocation).to eq(nil)
+
+    it 'returns NIL for an unallocated NMI' do
+      allocation = described_class.allocation('ZZZZZZZZZZZZ')
+      expect(allocation).to be_nil
     end
   end
 
@@ -79,145 +85,161 @@ describe AEMO::NMI do
   # ---
   describe '#initialize' do
     context 'valid' do
-      it 'should return a valid NMI' do
-        expect(AEMO::NMI.new('NM10000000')).to be_a(AEMO::NMI)
+      it 'returns a valid NMI' do
+        expect(described_class.new('NM10000000')).to be_a(described_class)
       end
-      it 'should return a valid NMI with MSATS' do
-        expect(AEMO::NMI.new('NM10000000', msats_detail: {})).to be_a(AEMO::NMI)
+
+      it 'returns a valid NMI with MSATS' do
+        expect(described_class.new('NM10000000', msats_detail: {})).to be_a(described_class)
       end
     end
+
     context 'invalid' do
-      it 'should raise an ArgumentError error' do
-        expect { AEMO::NMI.new('OOOOOOOOOO') }.to raise_error(ArgumentError)
+      it 'raises an ArgumentError error' do
+        expect { described_class.new('OOOOOOOOOO') }.to raise_error(ArgumentError)
       end
-      it 'should raise an ArgumentError error' do
-        expect { AEMO::NMI.new('NM100') }.to raise_error(ArgumentError)
+
+      it 'raises an ArgumentError error' do
+        expect { described_class.new('NM100') }.to raise_error(ArgumentError)
       end
-      it 'should raise an ArgumentError error' do
-        expect { AEMO::NMI.new }.to raise_error(ArgumentError)
+
+      it 'raises an ArgumentError error' do
+        expect { described_class.new }.to raise_error(ArgumentError)
       end
     end
   end
 
   describe '#valid_nmi?' do
-    it 'should validate nmi' do
+    it 'validates nmi' do
       json.each do |nmi|
-        a_nmi = AEMO::NMI.new(nmi['nmi'])
-        expect(a_nmi.valid_nmi?).to eq(true)
+        a_nmi = described_class.new(nmi['nmi'])
+        expect(a_nmi.valid_nmi?).to be(true)
       end
     end
   end
 
   describe '#checksum' do
-    it 'should return NMI\'s checksum' do
+    it 'returns NMI checksum' do
       json.each do |nmi|
-        a_nmi = AEMO::NMI.new(nmi['nmi'])
+        a_nmi = described_class.new(nmi['nmi'])
         expect(a_nmi.checksum).to eq(nmi['checksum'])
       end
     end
   end
 
   describe '#valid_checksum?(checksum)' do
-    it 'should validate valid checksums' do
+    it 'validates valid checksums' do
       json.each do |nmi|
-        a_nmi = AEMO::NMI.new(nmi['nmi'])
-        expect(a_nmi.valid_checksum?(nmi['checksum'])).to eq(true)
+        a_nmi = described_class.new(nmi['nmi'])
+        expect(a_nmi.valid_checksum?(nmi['checksum'])).to be(true)
       end
     end
-    it 'should not validate invalid checksums' do
+
+    it 'does not validate invalid checksums' do
       json.each do |nmi|
-        a_nmi = AEMO::NMI.new(nmi['nmi'])
-        expect(a_nmi.valid_checksum?((1 + nmi['checksum']) % 10)).to eq(false)
+        a_nmi = described_class.new(nmi['nmi'])
+        expect(a_nmi.valid_checksum?((1 + nmi['checksum']) % 10)).to be(false)
       end
     end
   end
 
   describe '#network' do
     # Positive test cases
-    it 'should return a network for a valid NMI' do
+    it 'returns a network for a valid NMI' do
       json.each do |nmi|
-        a_nmi = AEMO::NMI.new(nmi['nmi'])
+        a_nmi = described_class.new(nmi['nmi'])
         next if a_nmi.network.nil?
+
         expect(a_nmi.network).to be_a AEMO::NMI::Allocation
         expect(a_nmi.allocation).to be_a AEMO::NMI::Allocation
       end
     end
+
     # Negative test cases
-    it 'should not return a network for a NMI not allocated to a network' do
+    it 'does not return a network for a NMI not allocated to a network' do
       json.each do |nmi|
-        a_nmi = AEMO::NMI.new(nmi['nmi'])
+        a_nmi = described_class.new(nmi['nmi'])
         expect(a_nmi.network.class).to eq(NilClass) if a_nmi.network.nil?
       end
     end
   end
 
   describe '#friendly_address' do
-    it 'should return the empty string if the address is not a hash' do
-      nmi = AEMO::NMI.new('4001234567')
+    it 'returns the empty string if the address is not a hash' do
+      nmi = described_class.new('4001234567')
       nmi.address = 'An address'
       expect(nmi.friendly_address).to eq('')
     end
-    it 'should return a friendly address if the address is a hash' do
-      nmi = AEMO::NMI.new('4001234567')
+
+    it 'returns a friendly address if the address is a hash' do
+      nmi = described_class.new('4001234567')
       nmi.address = { number: '1', street: 'Bob', street_type: 'Street' }
       expect(nmi.friendly_address).to eq('1, Bob, Street')
     end
-    it 'should return a friendly address if the address is a nested hash' do
-      nmi = AEMO::NMI.new('4001234567')
+
+    it 'returns a friendly address if the address is a nested hash' do
+      nmi = described_class.new('4001234567')
       nmi.address = { house: { number: '1', suffix: 'B' }, street: 'Bob', street_type: 'Street' }
       expect(nmi.friendly_address).to eq('1 B, Bob, Street')
     end
   end
 
   describe '#current_daily_load' do
-    it 'should return zero for no data' do
-      @nmi = AEMO::NMI.new('4001234567')
+    it 'returns zero for no data' do
+      @nmi = described_class.new('4001234567')
       expect(@nmi.current_daily_load).to eq(0)
     end
   end
 
   describe '#current_annual_load' do
-    it 'should return zero for no data' do
-      @nmi = AEMO::NMI.new('4001234567')
+    it 'returns zero for no data' do
+      @nmi = described_class.new('4001234567')
       expect(@nmi.current_annual_load).to eq(0)
     end
   end
 
   describe '#meters_by_status' do
-    before(:each) do
-      @nmi = AEMO::NMI.new('4001234567')
-      @nmi.meters = [OpenStruct.new(status: 'C'), OpenStruct.new(status: 'R')]
+    before do
+      @nmi = described_class.new('4001234567')
+      @nmi.meters = [Struct::DataStream.new(status: 'C'), Struct::DataStream.new(status: 'R')]
     end
-    it 'should return current meters' do
+
+    it 'returns current meters' do
       expect(@nmi.meters_by_status.count).to eq(1)
     end
-    it 'should return retired meters' do
+
+    it 'returns retired meters' do
       expect(@nmi.meters_by_status('R').count).to eq(1)
     end
-    it 'should return zero meters for weird status' do
+
+    it 'returns zero meters for weird status' do
       expect(@nmi.meters_by_status('TMP').count).to eq(0)
     end
   end
 
   describe 'distribution loss factors' do
-    before(:each) do
-      @nmi = AEMO::NMI.new('4001234567')
+    before do
+      @nmi = described_class.new('4001234567')
       @nmi.dlf = 'BL0A'
       @nmi.tni = 'NGN2'
     end
+
     it 'has a valid DLF Code' do
       expect(@nmi.dlf).to eq('BL0A')
     end
+
     it 'has a DLF value' do
       Timecop.freeze('2016-06-01T00:00:00+1000') do
         expect(@nmi.dlfc_value.class).to eq(Float)
       end
     end
+
     it 'has DLF values' do
       Timecop.freeze('2016-06-01T00:00:00+1000') do
         expect(@nmi.dlfc_values.class).to eq(Array)
       end
     end
+
     it 'has historical values for DLF values' do
       valid_dlfc_values = [
         { datetime: '2003-06-01T00:00:00+1000', value: 1.0713 },
@@ -247,8 +269,8 @@ describe AEMO::NMI do
   end
 
   describe 'transmission node identifiers and loss factors' do
-    before(:each) do
-      @nmi = AEMO::NMI.new('4001234567')
+    before do
+      @nmi = described_class.new('4001234567')
       @nmi.dlf = 'BL0A'
       @nmi.tni = 'NGN2'
     end
@@ -256,16 +278,19 @@ describe AEMO::NMI do
     it 'has a valid TNI Code' do
       expect(@nmi.tni).to eq('NGN2')
     end
+
     it 'has a TNI value' do
       Timecop.freeze('2016-06-01T00:00:00+1000') do
         expect(@nmi.tni_value(Time.now).class).to eq(Float)
       end
     end
+
     it 'has TNI values' do
       Timecop.freeze('2016-06-01T00:00:00+1000') do
         expect(@nmi.tni_values.class).to eq(Array)
       end
     end
+
     it 'has historical values for TNI values' do
       valid_tni_values = [
         { datetime: '2014-06-01T00:00:00+1000', value: 1.0383 },
@@ -284,15 +309,16 @@ describe AEMO::NMI do
   end
 
   describe 'MSATS functions' do
-    it 'should get data' do
+    it 'gets data' do
       AEMO::MSATS.authorize('ER', 'ER', 'ER')
-      nmi = AEMO::NMI.new('4001234567')
+      nmi = described_class.new('4001234567')
       nmi.update_from_msats!
-      expect(nmi.msats_detail).to_not eq(nil)
+      expect(nmi.msats_detail).not_to be_nil
     end
-    it 'should return the hash of raw data' do
+
+    it 'returns the hash of raw data' do
       AEMO::MSATS.authorize('ER', 'ER', 'ER')
-      nmi = AEMO::NMI.new('4001234567')
+      nmi = described_class.new('4001234567')
       expect(nmi.raw_msats_nmi_detail.class).to eq(Hash)
     end
   end

data/spec/lib/aemo/region_spec.rb

@@ -4,55 +4,60 @@ require 'spec_helper'
 
 describe AEMO::Region do
   describe '.REGIONS' do
-    it 'should be a hash' do
+    it 'is a hash' do
       expect(AEMO::Region::REGIONS).to be_instance_of(Hash)
     end
   end
 
   describe 'creating a region' do
-    it 'should raise an error if invalid region' do
-      expect { AEMO::Region.new('BOTTOMS') }.to raise_error(ArgumentError)
+    it 'raises an error if invalid region' do
+      expect { described_class.new('BOTTOMS') }.to raise_error(ArgumentError)
     end
-    it 'should create if region valid' do
-      expect { AEMO::Region.new('NSW') }.not_to raise_error
+
+    it 'creates if region valid' do
+      expect { described_class.new('NSW') }.not_to raise_error
     end
   end
 
   describe 'AEMO::Region instance methods' do
-    before(:each) do
-      @nsw = AEMO::Region.new('NSW')
+    before do
+      @nsw = described_class.new('NSW')
     end
-    it 'should have an abbreviation' do
+
+    it 'has an abbreviation' do
       expect(@nsw.abbr).to eq('NSW')
     end
-    it 'should have a fullname' do
+
+    it 'has a fullname' do
       expect(@nsw.fullname).to eq('New South Wales')
     end
-    it 'should have to_s method' do
+
+    it 'has to_s method' do
       expect(@nsw.to_s).to eq('NSW')
     end
 
-    it 'should have a valid region' do
-      expect(@nsw.send(:valid_region?, 'NSW')).to eq(true)
+    it 'has a valid region' do
+      expect(@nsw.send(:valid_region?, 'NSW')).to be(true)
     end
 
-    it 'should have return invalid for invalid region' do
-      expect(@nsw.send(:valid_region?, 'BOB')).to eq(false)
+    it 'has return invalid for invalid region' do
+      expect(@nsw.send(:valid_region?, 'BOB')).to be(false)
     end
 
     describe 'AEMO::Region dispatch information' do
-      it 'should return current dispatch data' do
+      it 'returns current dispatch data' do
         expect(@nsw.current_dispatch.count).to eq(AEMO::Market.current_dispatch(@nsw.abbr).count)
       end
-      it 'should return current trading data' do
+
+      it 'returns current trading data' do
         expect(@nsw.current_trading.count).to eq(AEMO::Market.current_trading(@nsw.abbr).count)
       end
     end
   end
 
   describe 'AEMO::Region class methods' do
-    it 'should return all regions' do
-      expect(AEMO::Region.all.count).to eq(AEMO::Region::REGIONS.keys.count)
+    it 'returns all regions' do
+      expect(described_class.all.count).to eq(AEMO::Region::REGIONS.keys.count)
     end
   end
 end

data/spec/spec_helper.rb

@@ -18,7 +18,7 @@ require 'aemo'
 
 RSpec.configure do |config|
   # WebMock
-  config.before(:each) do
+  config.before do
     csv_headers = { 'Content-Type' => 'text/csv' }
     xml_headers = { 'Content-Type' => 'text/xml' }
 
@@ -45,43 +45,43 @@ RSpec.configure do |config|
       .to_return(status: 200, body: File.new('spec/fixtures/Market/DATA201502_NSW1.csv'), headers: csv_headers)
 
     # MSATS
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/C4\/ER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/C4/ER})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 200, body: File.new('spec/fixtures/MSATS/c4.xml'), headers: xml_headers)
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/MSATSLimits\/ER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/MSATSLimits/ER})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 200, body: File.new('spec/fixtures/MSATS/msats_limits.xml'), headers: xml_headers)
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/NMIDetail\/ER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/NMIDetail/ER})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 200, body: File.new('spec/fixtures/MSATS/nmi_details.xml'), headers: xml_headers)
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/NMIDiscovery\/ER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/NMIDiscovery/ER})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 200, body: File.new('spec/fixtures/MSATS/nmi_discovery_by_address.xml'), headers: xml_headers)
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/ParticipantSystemStatus\/ER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/ParticipantSystemStatus/ER})
       .with(headers: { 'Accept' => 'text/xml', 'Content-Type' => 'text/xml' })
       .to_return(status: 200, body: File.new('spec/fixtures/MSATS/participant_system_status.xml'), headers: xml_headers)
     # MSATS ERRORS
     # Invalid MSATS User
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/C4\/NOTER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/C4/NOTER})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 404, body: '', headers: xml_headers)
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/MSATSLimits\/NOTER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/MSATSLimits/NOTER})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 404, body: '', headers: xml_headers)
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/NMIDetail\/NOTER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/NMIDetail/NOTER})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 404, body: '', headers: xml_headers)
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/NMIDiscovery\/NOTER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/NMIDiscovery/NOTER})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 404, body: '', headers: xml_headers)
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/ParticipantSystemStatus\/NOTER})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/ParticipantSystemStatus/NOTER})
       .with(headers: { 'Accept' => 'text/xml', 'Content-Type' => 'text/xml' })
       .to_return(status: 404, body: '', headers: xml_headers)
     # Data errors
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/C4\/ER\?.+?NMI=4001234566.+?})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/C4/ER\?.+?NMI=4001234566.+?})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 404, body: '', headers: xml_headers)
-    stub_request(:get, %r{msats.prod.nemnet.net.au\/msats\/ws\/NMIDetail\/ER\?.+?nmi=4001234566.+?})
+    stub_request(:get, %r{msats.prod.nemnet.net.au/msats/ws/NMIDetail/ER\?.+?nmi=4001234566.+?})
       .with(headers: { 'Accept' => ['text/xml'], 'Content-Type' => 'text/xml' })
       .to_return(status: 404, body: '', headers: xml_headers)
   end