aemo 0.1.27 → 0.1.28

data/spec/aemo_spec.rb

@@ -5,5 +5,4 @@ describe AEMO do
     @klass = Class.new
     @klass.instance_eval { include AEMO }
   end
-  
-end
+end

data/spec/lib/aemo/market/interval_spec.rb

@@ -3,25 +3,25 @@ require 'spec_helper'
 describe AEMO::Market::Interval do
   describe 'AEMO::Market::Interval contstants' do
     it 'has INTERVALS' do
-      expect(AEMO::Market::Interval::INTERVALS).to eq({trading: 'Trading',dispatch: 'Dispatch'})
+      expect(AEMO::Market::Interval::INTERVALS).to eq(trading: 'Trading', dispatch: 'Dispatch')
     end
   end
   describe 'AEMO::Market::Interval instance methods' do
     before(:each) do
-      @interval = AEMO::Market::Interval.new("2016-03-01T00:30:00", {'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => 'TRADING'})
+      @interval = AEMO::Market::Interval.new('2016-03-01T00:30:00', 'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => 'TRADING')
     end
     it 'creates a valid interval' do
-      expect {AEMO::Market::Interval.new("2016-03-01T00:30:00", {'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => 'TRADING'})}.not_to raise_error
+      expect { AEMO::Market::Interval.new('2016-03-01T00:30:00', 'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => 'TRADING') }.not_to raise_error
     end
     it 'has a trailing datetime' do
-      expect(@interval.datetime).to eq(DateTime.parse("2016-03-01T00:30:00+1000"))
+      expect(@interval.datetime).to eq(DateTime.parse('2016-03-01T00:30:00+1000'))
     end
     it 'has a leading datetime' do
-      expect(@interval.datetime(false)).to eq(DateTime.parse("2016-03-01T00:00:00+1000"))
+      expect(@interval.datetime(false)).to eq(DateTime.parse('2016-03-01T00:00:00+1000'))
     end
     it 'has a leading datetime for dispatch' do
-      @interval = AEMO::Market::Interval.new("2016-03-01T00:30:00", {'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => ''})
-      expect(@interval.datetime(false)).to eq(DateTime.parse("2016-03-01T00:25:00+1000"))
+      @interval = AEMO::Market::Interval.new('2016-03-01T00:30:00', 'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => '')
+      expect(@interval.datetime(false)).to eq(DateTime.parse('2016-03-01T00:25:00+1000'))
     end
     it 'has an interval length' do
       expect(@interval.interval_length).to eq(Time.at(300))
@@ -30,17 +30,17 @@ describe AEMO::Market::Interval do
       expect(@interval.interval_type).to eq(:trading)
     end
     it 'is a trading interval' do
-      expect(@interval.is_trading?).to eq(true)
-      expect(@interval.is_dispatch?).to eq(false)
+      expect(@interval.trading?).to eq(true)
+      expect(@interval.dispatch?).to eq(false)
     end
     it 'is a dispatch interval' do
-      @interval = AEMO::Market::Interval.new("2016-03-01T00:30:00", {'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => ''})
+      @interval = AEMO::Market::Interval.new('2016-03-01T00:30:00', 'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => '')
       expect(@interval.interval_type).to eq(:dispatch)
     end
     it 'is a dispatch interval' do
-      @interval = AEMO::Market::Interval.new("2016-03-01T00:30:00", {'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => ''})
-      expect(@interval.is_trading?).to eq(false)
-      expect(@interval.is_dispatch?).to eq(true)
+      @interval = AEMO::Market::Interval.new('2016-03-01T00:30:00', 'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54, 'PERIODTYPE' => '')
+      expect(@interval.trading?).to eq(false)
+      expect(@interval.dispatch?).to eq(true)
     end
     it 'has a valid value' do
       expect(@interval.value).to eq((@interval.total_demand * @interval.rrp).round(2))

data/spec/lib/aemo/market_spec.rb

@@ -1,12 +1,14 @@
 require 'spec_helper'
 
 describe AEMO::Market do
-  it "returns the SupportedFormats constant for subclasses" do
-    class MyParser < HTTParty::Parser
-      SupportedFormats = {"application/atom+xml" => :atom}
-    end
-    expect(MyParser.formats).to eq({"application/atom+xml" => :atom})
-  end
+  # it 'returns the SupportedFormats constant for subclasses' do
+  #   class MyParser < HTTParty::Parser
+  #     SupportedFormats.merge!(
+  #       {'application/atom+xml' => :atom }
+  #     )
+  #   end
+  #   expect(MyParser.formats).to include('application/atom+xml' => :atom)
+  # end
 
   describe 'Dispatch data' do
     it 'has an array of data' do

data/spec/lib/aemo/msats_spec.rb

@@ -10,7 +10,7 @@ describe AEMO::MSATS do
   describe 'class methods' do
     describe 'nmi details' do
       before(:each) do
-        AEMO::MSATS.authorize("ER","ER","ER")
+        AEMO::MSATS.authorize('ER', 'ER', 'ER')
       end
 
       it 'should get data for a valid nmi' do
@@ -18,34 +18,34 @@ describe AEMO::MSATS do
         expect(nmi_detail_query.class).to eq(Hash)
       end
       it 'should get a 404 for a nonexistent nmi' do
-        nmi_detail_query = AEMO::MSATS.nmi_detail('4001234566')
+        # nmi_detail_query = AEMO::MSATS.nmi_detail('4001234566')
         # TODO workout what the different errors are here...
       end
       it 'should raise an error for a bad nmi' do
-        expect {AEMO::MSATS.nmi_detail('BOBISAFISH')}.to raise_error(ArgumentError)
+        expect { AEMO::MSATS.nmi_detail('BOBISAFISH') }.to raise_error(ArgumentError)
       end
     end
 
     describe '#c4' do
       before(:each) do
-        AEMO::MSATS.authorize("ER","ER","ER")
+        AEMO::MSATS.authorize('ER', 'ER', 'ER')
       end
 
       it 'should return a hash of information' do
-        AEMO::MSATS.c4("4001234567",DateTime.now,DateTime.now,DateTime.now)
+        AEMO::MSATS.c4('4001234567', DateTime.now, DateTime.now, DateTime.now)
       end
       it 'should raise an error for a bad nmi' do
-        expect {AEMO::MSATS.c4('BOBISAFISH')}.to raise_error(ArgumentError)
+        expect { AEMO::MSATS.c4('BOBISAFISH') }.to raise_error(ArgumentError)
       end
       it 'should return a hash of information' do
-        AEMO::MSATS.c4("4001234566",DateTime.now,DateTime.now,DateTime.now)
+        # AEMO::MSATS.c4('4001234566', DateTime.now, DateTime.now, DateTime.now)
         # TODO workout what the different errors are here...
       end
     end
 
     describe '#msats_limits' do
       before(:each) do
-        AEMO::MSATS.authorize("ER","ER","ER")
+        AEMO::MSATS.authorize('ER', 'ER', 'ER')
       end
 
       it 'should give details of msats_limits' do
@@ -55,30 +55,29 @@ describe AEMO::MSATS do
 
     describe '#nmi_discovery_by_*' do
       before(:each) do
-        AEMO::MSATS.authorize("ER","ER","ER")
+        AEMO::MSATS.authorize('ER', 'ER', 'ER')
       end
       it 'should find by address' do
-        expect(AEMO::MSATS.nmi_discovery_by_address('NSW',{ house_number: 6, street_name: 'Macquarie', suburb_or_place_or_locality: 'Sydney', postcode: 2000}).class).to eq(Array)
+        expect(AEMO::MSATS.nmi_discovery_by_address('NSW', house_number: 6, street_name: 'Macquarie', suburb_or_place_or_locality: 'Sydney', postcode: 2000).class).to eq(Array)
       end
       it 'should find by meter_serial_number' do
-        expect(AEMO::MSATS.nmi_discovery_by_meter_serial_number('NSW',666).class).to eq(Array)
+        expect(AEMO::MSATS.nmi_discovery_by_meter_serial_number('NSW', 666).class).to eq(Array)
       end
       it 'should find by meter_serial_number' do
-        expect {AEMO::MSATS.nmi_discovery_by_delivery_point_identifier('NSW',666)}.to raise_error(ArgumentError)
+        expect { AEMO::MSATS.nmi_discovery_by_delivery_point_identifier('NSW', 666) }.to raise_error(ArgumentError)
       end
       it 'should find by meter_serial_number' do
-        expect(AEMO::MSATS.nmi_discovery_by_delivery_point_identifier('NSW',10000001).class).to eq(Array)
+        expect(AEMO::MSATS.nmi_discovery_by_delivery_point_identifier('NSW', 10_000_001).class).to eq(Array)
       end
     end
 
     describe '#system_status' do
       before(:each) do
-        AEMO::MSATS.authorize("ER","ER","ER")
+        AEMO::MSATS.authorize('ER', 'ER', 'ER')
       end
       it 'should provide a status' do
         AEMO::MSATS.system_status
       end
     end
-
   end
 end

data/spec/lib/aemo/nem12_spec.rb

@@ -2,11 +2,10 @@ require 'spec_helper'
 require 'json'
 
 describe AEMO::NEM12 do
-
-  let(:json) { JSON.parse(fixture("nmi_checksum.json").read) }
+  let(:json) { JSON.parse(fixture('nmi_checksum.json').read) }
 
   describe '::RECORD_INDICATORS' do
-    it "should be a hash" do
+    it 'should be a hash' do
       expect(AEMO::NEM12::RECORD_INDICATORS.class).to eq(Hash)
     end
   end
@@ -16,27 +15,27 @@ describe AEMO::NEM12 do
 
   describe '.parse_nem12_file' do
     it 'should parse a file' do
-      Dir.entries(File.join(File.dirname(__FILE__),'..','..','fixtures','NEM12')).reject{|f| %w(. .. .DS_Store).include?(f)}.each do |file|
-        nem12 = AEMO::NEM12.parse_nem12_file(fixture(File.join('NEM12',file)))
+      Dir.entries(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'NEM12')).reject { |f| %w(. .. .DS_Store).include?(f) }.each do |file|
+        # nem12 = AEMO::NEM12.parse_nem12_file(fixture(File.join('NEM12', file)))
       end
     end
   end
 
   describe '#parse_nem12_100' do
     it 'should raise datetime error' do
-      expect {AEMO::NEM12.parse_nem12_100('100,NEM12,666,CNRGYMDP,NEMMCO')}.to raise_error(ArgumentError)
+      expect { AEMO::NEM12.parse_nem12_100('100,NEM12,666,CNRGYMDP,NEMMCO') }.to raise_error(ArgumentError)
     end
     it 'should raise datetime error' do
-      expect {AEMO::NEM12.parse_nem12_100('100,NEM12,666,CNRGYMDP,NEMMCO', {strict: true})}.to raise_error(ArgumentError)
+      expect { AEMO::NEM12.parse_nem12_100('100,NEM12,666,CNRGYMDP,NEMMCO', strict: true) }.to raise_error(ArgumentError)
     end
     it 'should not raise an error' do
-      expect {AEMO::NEM12.parse_nem12_100('100,NEM12,201603010000,CNRGYMDP,NEMMCO', {strict: true})}.not_to raise_error
+      expect { AEMO::NEM12.parse_nem12_100('100,NEM12,201603010000,CNRGYMDP,NEMMCO', strict: true) }.not_to raise_error
     end
   end
 
   describe '#parse_nem12_200' do
     before(:each) do
-      @nem12 = AEMO::NEM12.parse_nem12_100('100,NEM12,201603010000,CNRGYMDP,NEMMCO', {strict: true})
+      @nem12 = AEMO::NEM12.parse_nem12_100('100,NEM12,201603010000,CNRGYMDP,NEMMCO', strict: true)
     end
   end
 
@@ -53,6 +52,5 @@ describe AEMO::NEM12 do
   end
 
   describe '#flag_to_s' do
-
   end
 end

data/spec/lib/aemo/nmi_spec.rb

@@ -2,24 +2,23 @@ require 'spec_helper'
 require 'json'
 
 describe AEMO::NMI do
-
-  let(:json) { JSON.parse(fixture("nmi_checksum.json").read) }
+  let(:json) { JSON.parse(fixture('nmi_checksum.json').read) }
 
   # ---
   # CLASS CONSTANTS
   # ---
   describe '::NMI_ALLOCATIONS' do
-    it "should be a hash" do
+    it 'should be a hash' do
       expect(AEMO::NMI::NMI_ALLOCATIONS.class).to eq(Hash)
     end
   end
   describe '::TNI_CODES' do
-    it "should be a hash" do
+    it 'should be 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 'should be a hash' do
       expect(AEMO::NMI::DLF_CODES.class).to eq(Hash)
     end
   end
@@ -28,31 +27,35 @@ describe AEMO::NMI do
   # CLASS METHODS
   # ---
   describe '.valid_nmi?(nmi)' do
-    it 'should validate nmi' do
-      json.each do |nmi|
-        expect(AEMO::NMI.valid_nmi?(nmi['nmi'])).to eq(true)
+    context 'valid' do
+      it 'should validate nmi' do
+        json.each do |nmi|
+          expect(AEMO::NMI.valid_nmi?(nmi['nmi'])).to eq(true)
+        end
       end
     end
-    it "should invalidate" do
-      expect(AEMO::NMI.valid_nmi?("OOOOOOOOOO")).to eq(false)
-    end
-    it "should invalidate" do
-      expect(AEMO::NMI.valid_nmi?("NM100")).to eq(false)
-    end
-    it "should invalidate" do
-      expect{AEMO::NMI.valid_nmi?()}.to raise_error(ArgumentError)
+    context 'invalid' do
+      it 'should invalidate' do
+        expect(AEMO::NMI.valid_nmi?('OOOOOOOOOO')).to eq(false)
+      end
+      it 'should invalidate' do
+        expect(AEMO::NMI.valid_nmi?('NM100')).to eq(false)
+      end
+      it 'should invalidate' do
+        expect { AEMO::NMI.valid_nmi? }.to raise_error(ArgumentError)
+      end
     end
   end
 
-  describe '.self.valid_checksum?(nmi,checksum)' do
+  describe '.valid_checksum?(nmi, checksum)' do
     it 'should validate valid nmi and checksums' do
       json.each do |nmi|
-        expect(AEMO::NMI.valid_checksum?(nmi['nmi'],nmi['checksum'])).to eq(true)
+        expect(AEMO::NMI.valid_checksum?(nmi['nmi'], nmi['checksum'])).to eq(true)
       end
     end
   end
 
-  describe '.self.network?(nmi)' do
+  describe '.network?(nmi)' do
     it 'should return a network for an allocated NMI' do
       network = AEMO::NMI.network('NCCCC00000')
       expect(network.to_a[0].last[:title]).to eq('Ausgrid')
@@ -67,21 +70,31 @@ describe AEMO::NMI do
   # INSTANCE METHODS
   # ---
   describe '#initialize' do
-    it "should raise an ArgumentError error" do
-      expect{ AEMO::NMI.new("OOOOOOOOOO") }.to raise_error(ArgumentError)
-    end
-    it "should raise an ArgumentError error" do
-      expect{ AEMO::NMI.new("NM100") }.to raise_error(ArgumentError)
+    context 'valid' do
+      it 'should return a valid NMI' do
+        expect(AEMO::NMI.new('NM10000000')).to be_a(AEMO::NMI)
+      end
+      it 'should return a valid NMI with MSATS' do
+        expect(AEMO::NMI.new('NM10000000', { msats_detail: {} })).to be_a(AEMO::NMI)
+      end
     end
-    it "should raise an ArgumentError error" do
-      expect{ AEMO::NMI.new() }.to raise_error(ArgumentError)
+    context 'invalid' do
+      it 'should raise an ArgumentError error' do
+        expect { AEMO::NMI.new('OOOOOOOOOO') }.to raise_error(ArgumentError)
+      end
+      it 'should raise an ArgumentError error' do
+        expect { AEMO::NMI.new('NM100') }.to raise_error(ArgumentError)
+      end
+      it 'should raise an ArgumentError error' do
+        expect { AEMO::NMI.new }.to raise_error(ArgumentError)
+      end
     end
   end
   describe '#valid_nmi?' do
     it 'should validate nmi' do
       json.each do |nmi|
-        _nmi = AEMO::NMI.new(nmi['nmi'])
-        expect(_nmi.valid_nmi?).to eq(true)
+        a_nmi = AEMO::NMI.new(nmi['nmi'])
+        expect(a_nmi.valid_nmi?).to eq(true)
       end
     end
   end
@@ -89,8 +102,8 @@ describe AEMO::NMI do
   describe '#checksum' do
     it 'should return NMI\'s checksum' do
       json.each do |nmi|
-        _nmi = AEMO::NMI.new(nmi['nmi'])
-        expect(_nmi.checksum).to eq(nmi['checksum'])
+        a_nmi = AEMO::NMI.new(nmi['nmi'])
+        expect(a_nmi.checksum).to eq(nmi['checksum'])
       end
     end
   end
@@ -98,14 +111,14 @@ describe AEMO::NMI do
   describe '#valid_checksum?(checksum)' do
     it 'should validate valid checksums' do
       json.each do |nmi|
-        _nmi = AEMO::NMI.new(nmi['nmi'])
-        expect(_nmi.valid_checksum?(nmi['checksum'])).to eq(true)
+        a_nmi = AEMO::NMI.new(nmi['nmi'])
+        expect(a_nmi.valid_checksum?(nmi['checksum'])).to eq(true)
       end
     end
     it 'should not validate invalid checksums' do
       json.each do |nmi|
-        _nmi = AEMO::NMI.new(nmi['nmi'])
-        expect(_nmi.valid_checksum?((1+nmi['checksum'])%10)).to eq(false)
+        a_nmi = AEMO::NMI.new(nmi['nmi'])
+        expect(a_nmi.valid_checksum?((1 + nmi['checksum']) % 10)).to eq(false)
       end
     end
   end
@@ -114,47 +127,43 @@ describe AEMO::NMI do
     # Positive test cases
     it 'should return a network for a valid NMI' do
       json.each do |nmi|
-        _nmi = AEMO::NMI.new(nmi['nmi'])
-        unless _nmi.network.nil?
-          expect(_nmi.network.class).to eq(Hash)
-        end
+        a_nmi = AEMO::NMI.new(nmi['nmi'])
+        expect(a_nmi.network.class).to eq(Hash) unless a_nmi.network.nil?
       end
     end
     # Negative test cases
     it 'should not return a network for a NMI not allocated to a network' do
       json.each do |nmi|
-        _nmi = AEMO::NMI.new(nmi['nmi'])
-        if _nmi.network.nil?
-          expect(_nmi.network.class).to eq(NilClass)
-        end
+        a_nmi = AEMO::NMI.new(nmi['nmi'])
+        expect(a_nmi.network.class).to eq(NilClass) if a_nmi.network.nil?
       end
     end
   end
 
-  describe "#friendly_address" do
+  describe '#friendly_address' do
     it 'should return the empty string if the address is not a hash' do
-      nmi = AEMO::NMI.new("4001234567")
-      nmi.address = "An address"
+      nmi = AEMO::NMI.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")
-      nmi.address = { number: '1', street: 'Bob', street_type: 'Street'}
+      nmi = AEMO::NMI.new('4001234567')
+      nmi.address = { number: '1', street: 'Bob', street_type: 'Street' }
       expect(nmi.friendly_address).to eq('1, Bob, Street')
     end
   end
 
-  describe "#current_daily_load" do
-    it "should return zero for no data" do
-      @nmi = AEMO::NMI.new("4001234567")
+  describe '#current_daily_load' do
+    it 'should return zero for no data' do
+      @nmi = AEMO::NMI.new('4001234567')
       expect(@nmi.current_daily_load).to eq(0)
     end
   end
 
-  describe "#meters_by_status" do
+  describe '#meters_by_status' do
     before(:each) do
-      @nmi = AEMO::NMI.new("4001234567")
-      @nmi.meters = [OpenStruct.new(status: 'C'),OpenStruct.new(status: 'R')]
+      @nmi = AEMO::NMI.new('4001234567')
+      @nmi.meters = [OpenStruct.new(status: 'C'), OpenStruct.new(status: 'R')]
     end
     it 'should return current meters' do
       expect(@nmi.meters_by_status.count).to eq(1)
@@ -167,46 +176,45 @@ describe AEMO::NMI do
     end
   end
 
-  describe "distribution loss factors" do
+  describe 'distribution loss factors' do
     before(:each) do
-      @nmi = AEMO::NMI.new("4001234567")
-      @nmi.dlf = "BL0A"
-      @nmi.tni = "NGN2"
+      @nmi = AEMO::NMI.new('4001234567')
+      @nmi.dlf = 'BL0A'
+      @nmi.tni = 'NGN2'
     end
-    it "has a valid DLF Code" do
-      expect(@nmi.dlf).to eq("BL0A")
+    it 'has a valid DLF Code' do
+      expect(@nmi.dlf).to eq('BL0A')
     end
-    it "has a DLF value" do
+    it 'has a DLF value' do
       expect(@nmi.dlfc_value.class).to eq(Float)
     end
   end
 
-  describe "transmission node identifiers and loss factors" do
+  describe 'transmission node identifiers and loss factors' do
     before(:each) do
-      @nmi = AEMO::NMI.new("4001234567")
-      @nmi.dlf = "BL0A"
-      @nmi.tni = "NGN2"
+      @nmi = AEMO::NMI.new('4001234567')
+      @nmi.dlf = 'BL0A'
+      @nmi.tni = 'NGN2'
     end
-    it "has a valid TNI Code" do
-      expect(@nmi.tni).to eq("NGN2")
+    it 'has a valid TNI Code' do
+      expect(@nmi.tni).to eq('NGN2')
     end
-    it "has a TNI value" do
+    it 'has a TNI value' do
       expect(@nmi.tni_value.class).to eq(Float)
     end
   end
 
-  describe "MSATS functions" do
+  describe 'MSATS functions' do
     it 'should get data' do
-      AEMO::MSATS.authorize("ER","ER","ER")
+      AEMO::MSATS.authorize('ER', 'ER', 'ER')
       nmi = AEMO::NMI.new('4001234567')
       nmi.update_from_msats!
       expect(nmi.msats_detail).to_not eq(nil)
     end
     it 'should return the hash of raw data' do
-      AEMO::MSATS.authorize("ER","ER","ER")
+      AEMO::MSATS.authorize('ER', 'ER', 'ER')
       nmi = AEMO::NMI.new('4001234567')
       expect(nmi.raw_msats_nmi_detail.class).to eq(Hash)
     end
   end
-
 end