aemo 0.5.0 → 0.6.0

data/lib/aemo/nmi.rb

@@ -5,7 +5,7 @@ require 'json'
 require 'time'
 require 'ostruct'
 
-require 'aemo/nmi/allocation.rb'
+require 'aemo/nmi/allocation'
 
 module AEMO
   # [AEMO::NMI]
@@ -22,11 +22,11 @@ module AEMO
       'ACT' => 'Australian Capital Territory',
       'NSW' => 'New South Wales',
       'QLD' => 'Queensland',
-      'SA'  => 'South Australia',
+      'SA' => 'South Australia',
       'TAS' => 'Tasmania',
       'VIC' => 'Victoria',
-      'WA'  => 'Western Australia',
-      'NT'  => 'Northern Territory'
+      'WA' => 'Western Australia',
+      'NT' => 'Northern Territory'
     }.freeze
 
     # Transmission Node Identifier Codes are loaded from a json file
@@ -79,7 +79,7 @@ module AEMO
       # @param [String] nmi the nmi to be checked
       # @return [Boolean] whether or not the nmi is valid
       def valid_nmi?(nmi)
-        ((nmi.length == 10) && !nmi.match(/^([A-HJ-NP-Z\d]{10})/).nil?)
+        (nmi.length == 10) && !nmi.match(/^([A-HJ-NP-Z\d]{10})/).nil?
       end
 
       # A function to calculate the checksum value for a given National Meter
@@ -159,14 +159,13 @@ module AEMO
     #   Identifier
     def checksum
       summation = 0
-      @nmi.reverse.split(//).each_index do |i|
+      @nmi.reverse.chars.each_index do |i|
         value = nmi[nmi.length - i - 1].ord
         value *= 2 if i.even?
-        value = value.to_s.split(//).map(&:to_i).reduce(:+)
+        value = value.to_s.chars.map(&:to_i).reduce(:+)
         summation += value
       end
-      checksum = (10 - (summation % 10)) % 10
-      checksum
+      (10 - (summation % 10)) % 10
     end
 
     # Provided MSATS is configured, gets the MSATS data for the NMI
@@ -174,6 +173,7 @@ module AEMO
     # @return [Hash] MSATS NMI Detail data
     def raw_msats_nmi_detail(options = {})
       raise ArgumentError, 'MSATS has no authentication credentials' unless AEMO::MSATS.can_authenticate?
+
       AEMO::MSATS.nmi_detail(@nmi, options)
     end
 
@@ -233,7 +233,7 @@ module AEMO
         data_streams = @msats_detail['DataStreams']['DataStream']
         data_streams = [data_streams] if data_streams.is_a?(Hash) # Deal with issue of only one existing
         data_streams.each do |stream|
-          @data_streams << OpenStruct.new(
+          @data_streams << Struct::DataStream.new(
             suffix: stream['Suffix'],
             profile_name: stream['ProfileName'],
             averaged_daily_load: stream['AveragedDailyLoad'],
@@ -270,10 +270,10 @@ module AEMO
       @meters.select { |x| x.status == status.to_s }
     end
 
-    # Returns the data_stream OpenStructs for the requested status (A/I)
+    # Returns the data_stream Structs for the requested status (A/I)
     #
     # @param [String] status the stateus [A|I]
-    # @return [Array<OpenStruct>] Returns an array of OpenStructs for the
+    # @return [Array<Struct>] Returns an array of Structs for the
     #   current Meters
     def data_streams_by_status(status = 'A')
       @data_streams.select { |x| x.status == status.to_s }
@@ -297,19 +297,20 @@ module AEMO
 
     # A function to return the distribution loss factor value for a given date
     #
-    # @param [DateTime, Time] datetime the date for the distribution loss factor
+    # @param [DateTime, ::Time] datetime the date for the distribution loss factor
     #   value
     # @return [nil, float] the distribution loss factor value
-    def dlfc_value(datetime = Time.now)
+    def dlfc_value(datetime = ::Time.now)
       if @dlf.nil?
         raise 'No DLF set, ensure that you have set the value either via the' \
               'update_from_msats! function or manually'
       end
       raise 'DLF is invalid' unless DLF_CODES.keys.include?(@dlf)
-      raise 'Invalid date' unless [DateTime, Time].include?(datetime.class)
+      raise 'Invalid date' unless [DateTime, ::Time].include?(datetime.class)
+
       possible_values = DLF_CODES[@dlf].select do |x|
-        Time.parse(x['FromDate']) <= datetime &&
-          Time.parse(x['ToDate']) >= datetime
+        ::Time.parse(x['FromDate']) <= datetime &&
+          ::Time.parse(x['ToDate']) >= datetime
       end
       if possible_values.empty?
         nil
@@ -320,61 +321,70 @@ module AEMO
 
     # A function to return the distribution loss factor value for a given date
     #
-    # @param [DateTime, Time] start the date for the distribution loss factor value
-    # @param [DateTime, Time] finish the date for the distribution loss factor value
+    # @param [DateTime, ::Time] start the date for the distribution loss factor value
+    # @param [DateTime, ::Time] finish the date for the distribution loss factor value
     # @return [Array(Hash)] array of hashes of start, finish and value
-    def dlfc_values(start = Time.now, finish = Time.now)
+    def dlfc_values(start = ::Time.now, finish = ::Time.now)
       if @dlf.nil?
-        raise 'No DLF set, ensure that you have set the value either via the '\
+        raise 'No DLF set, ensure that you have set the value either via the ' \
               'update_from_msats! function or manually'
       end
       raise 'DLF is invalid' unless DLF_CODES.keys.include?(@dlf)
-      raise 'Invalid start' unless [DateTime, Time].include?(start.class)
-      raise 'Invalid finish' unless [DateTime, Time].include?(finish.class)
+      raise 'Invalid start' unless [DateTime, ::Time].include?(start.class)
+      raise 'Invalid finish' unless [DateTime, ::Time].include?(finish.class)
       raise 'start cannot be after finish' if start > finish
-      DLF_CODES[@dlf].reject { |x| start > Time.parse(x['ToDate']) || finish < Time.parse(x['FromDate']) }
+
+      DLF_CODES[@dlf].reject { |x| start > ::Time.parse(x['ToDate']) || finish < ::Time.parse(x['FromDate']) }
                      .map { |x| { 'start' => x['FromDate'], 'finish' => x['ToDate'], 'value' => x['Value'].to_f } }
     end
 
     # A function to return the transmission node identifier loss factor value for a given date
     #
-    # @param [DateTime, Time] datetime the date for the distribution loss factor value
+    # @param [DateTime, ::Time] datetime the date for the distribution loss factor value
     # @return [nil, float] the transmission node identifier loss factor value
-    def tni_value(datetime = Time.now)
+    def tni_value(datetime = ::Time.now)
       if @tni.nil?
-        raise 'No TNI set, ensure that you have set the value either via the '\
+        raise 'No TNI set, ensure that you have set the value either via the ' \
               'update_from_msats! function or manually'
       end
       raise 'TNI is invalid' unless TNI_CODES.keys.include?(@tni)
-      raise 'Invalid date' unless [DateTime, Time].include?(datetime.class)
-      possible_values = TNI_CODES[@tni].select { |x| Time.parse(x['FromDate']) <= datetime && datetime <= Time.parse(x['ToDate']) }
+      raise 'Invalid date' unless [DateTime, ::Time].include?(datetime.class)
+
+      possible_values = TNI_CODES[@tni].select do |x|
+        ::Time.parse(x['FromDate']) <= datetime && datetime <= ::Time.parse(x['ToDate'])
+      end
       return nil if possible_values.empty?
-      possible_values = possible_values.first['mlf_data']['loss_factors'].select { |x| Time.parse(x['start']) <= datetime && datetime <= Time.parse(x['finish']) }
+
+      possible_values = possible_values.first['mlf_data']['loss_factors'].select do |x|
+        ::Time.parse(x['start']) <= datetime && datetime <= ::Time.parse(x['finish'])
+      end
       return nil if possible_values.empty?
+
       possible_values.first['value'].to_f
     end
 
     # A function to return the transmission node identifier loss factor value for a given date
     #
-    # @param [DateTime, Time] start the date for the distribution loss factor value
-    # @param [DateTime, Time] finish the date for the distribution loss factor value
+    # @param [DateTime, ::Time] start the date for the distribution loss factor value
+    # @param [DateTime, ::Time] finish the date for the distribution loss factor value
     # @return [Array(Hash)] array of hashes of start, finish and value
-    def tni_values(start = Time.now, finish = Time.now)
+    def tni_values(start = ::Time.now, finish = ::Time.now)
       if @tni.nil?
-        raise 'No TNI set, ensure that you have set the value either via the '\
+        raise 'No TNI set, ensure that you have set the value either via the ' \
               'update_from_msats! function or manually'
       end
       raise 'TNI is invalid' unless TNI_CODES.keys.include?(@tni)
-      raise 'Invalid start' unless [DateTime, Time].include?(start.class)
-      raise 'Invalid finish' unless [DateTime, Time].include?(finish.class)
+      raise 'Invalid start' unless [DateTime, ::Time].include?(start.class)
+      raise 'Invalid finish' unless [DateTime, ::Time].include?(finish.class)
       raise 'start cannot be after finish' if start > finish
 
       possible_values = TNI_CODES[@tni].reject do |tni_code|
-        start > Time.parse(tni_code['ToDate']) ||
-          finish < Time.parse(tni_code['FromDate'])
+        start > ::Time.parse(tni_code['ToDate']) ||
+          finish < ::Time.parse(tni_code['FromDate'])
       end
 
       return nil if possible_values.empty?
+
       possible_values.map { |x| x['mlf_data']['loss_factors'] }
     end
   end

data/lib/aemo/region.rb

@@ -12,11 +12,11 @@ module AEMO
       'ACT' => 'Australian Capital Territory',
       'NSW' => 'New South Wales',
       'QLD' => 'Queensland',
-      'SA'  => 'South Australia',
+      'SA' => 'South Australia',
       'TAS' => 'Tasmania',
       'VIC' => 'Victoria',
-      'NT'  => 'Northern Territory',
-      'WA'  => 'Western Australia'
+      'NT' => 'Northern Territory',
+      'WA' => 'Western Australia'
     }.freeze
 
     attr_accessor :region
@@ -34,6 +34,7 @@ module AEMO
     # @return [self]
     def initialize(region)
       raise ArgumentError, "Region '#{region}' is not valid." unless valid_region?(region)
+
       @region = region.upcase
       @full_name = REGIONS[@region]
       @current_trading = []

data/lib/aemo/register.rb

@@ -28,14 +28,14 @@ module AEMO
     # @return [AEMO::Register] description of returned object
     def self.from_hash(register)
       AEMO::Register.new(
-        controlled_load:     register['ControlledLoad'] == 'Y',
-        dial_format:         register['DialFormat'],
-        multiplier:          register['Multiplier'],
+        controlled_load: register['ControlledLoad'] == 'Y',
+        dial_format: register['DialFormat'],
+        multiplier: register['Multiplier'],
         network_tariff_code: register['NetworkTariffCode'],
-        register_id:         register['RegisterID'],
-        status:              register['Status'],
-        time_of_day:         register['TimeOfDay'],
-        unit_of_measure:     register['UnitOfMeasure']
+        register_id: register['RegisterID'],
+        status: register['Status'],
+        time_of_day: register['TimeOfDay'],
+        unit_of_measure: register['UnitOfMeasure']
       )
     end
   end

data/lib/aemo/struct.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Struct.new('DataStream', :suffix, :profile_name, :averaged_daily_load, :data_stream_type, :status, keyword_init: true)

data/lib/aemo/time.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'active_support/all'
+
+require_relative 'exceptions/time_error'
+
+module AEMO
+  # [AEMO::Time] provides time helpers for AEMO services.
+  module Time
+    NEMTIMEZONE = 'Australia/Brisbane'
+    TIMESTAMP14 = '%Y%m%d%H%M%S'
+    TIMESTAMP14_PATTERN = /^\d{4}\d{2}\d{2}\d{2}\d{2}\d{2}$/
+    TIMESTAMP12 = '%Y%m%d%H%M'
+    TIMESTAMP12_PATTERN = /^\d{4}\d{2}\d{2}\d{2}\d{2}$/
+    TIMESTAMP8 = '%Y%m%d'
+    TIMESTAMP8_PATTERN = /^\d{4}\d{2}\d{2}$/
+
+    class << self
+      # Format a time to a timestamp 14.
+      #
+      # @param [Time] time
+      # @return [String]
+      def format_timestamp14(time)
+        time.in_time_zone(NEMTIMEZONE).strftime(TIMESTAMP14)
+      end
+
+      # Format a time to a timestamp 12.
+      #
+      # @param [Time] time
+      # @return [String]
+      def format_timestamp12(time)
+        time.in_time_zone(NEMTIMEZONE).strftime(TIMESTAMP12)
+      end
+
+      # Format a time to a timestamp 8.
+      #
+      # @param [Time] time
+      # @return [String]
+      def format_timestamp8(time)
+        time.in_time_zone(NEMTIMEZONE).strftime(TIMESTAMP8)
+      end
+
+      # Parse a 14 character timestamp.
+      #
+      # @param [String] string
+      # @raise [AEMO::TimeError]
+      # @return [Time]
+      def parse_timestamp14(string)
+        raise AEMO::TimeError unless string.match(TIMESTAMP14_PATTERN)
+
+        ::Time.find_zone(NEMTIMEZONE).strptime(string, TIMESTAMP14)
+      end
+
+      # Parse a 12 character timestamp.
+      #
+      # @param [String] string
+      # @return [Time]
+      def parse_timestamp12(string)
+        raise AEMO::TimeError unless string.match(TIMESTAMP12_PATTERN)
+
+        ::Time.find_zone(NEMTIMEZONE).strptime(string, TIMESTAMP12)
+      end
+
+      # Parse an 8 character date.
+      #
+      # @param [String] string
+      # @return [Time]
+      def parse_timestamp8(string)
+        raise AEMO::TimeError unless string.match(TIMESTAMP8_PATTERN)
+
+        ::Time.find_zone(NEMTIMEZONE).strptime(string, TIMESTAMP8)
+      end
+
+      # Check if a string is a valid timestamp 14.
+      #
+      # @param [String] string
+      # @return [Boolean]
+      def valid_timestamp14?(string)
+        parse_timestamp14(string)
+
+        true
+      rescue AEMO::TimeError
+        false
+      end
+
+      # Check if a string is a valid timestamp 12.
+      #
+      # @param [String] string
+      # @return [Boolean]
+      def valid_timestamp12?(string)
+        parse_timestamp12(string)
+
+        true
+      rescue AEMO::TimeError
+        false
+      end
+
+      # Check if a string is a valid timestamp 8.
+      #
+      # @param [String] string
+      # @return [Boolean]
+      def valid_timestamp8?(string)
+        parse_timestamp8(string)
+
+        true
+      rescue AEMO::TimeError
+        false
+      end
+    end
+  end
+end

data/lib/aemo/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# -*- coding: UTF-8 -*-
 #
 # Copyright 2014 Joel Courtney
 #
@@ -24,7 +23,7 @@
 # @author Joel Courtney <euphemize@gmail.com>
 module AEMO
   # aemo version
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 
   # aemo version split amongst different revisions
   MAJOR_VERSION, MINOR_VERSION, REVISION = VERSION.split('.').map(&:to_i)

data/lib/aemo.rb

@@ -4,17 +4,19 @@ require 'active_support/all'
 require 'httparty'
 require 'csv'
 
-require 'aemo/region.rb'
-require 'aemo/market.rb'
-require 'aemo/market/interval.rb'
-require 'aemo/market/node.rb'
-require 'aemo/meter.rb'
-require 'aemo/nem12.rb'
-require 'aemo/nmi.rb'
-require 'aemo/msats.rb'
-require 'aemo/register.rb'
-require 'aemo/version.rb'
-require 'aemo/exceptions/invalid_nmi_allocation_type.rb'
+require 'aemo/struct'
+require 'aemo/time'
+require 'aemo/region'
+require 'aemo/market'
+require 'aemo/market/interval'
+require 'aemo/market/node'
+require 'aemo/meter'
+require 'aemo/nem12'
+require 'aemo/nmi'
+require 'aemo/msats'
+require 'aemo/register'
+require 'aemo/version'
+require 'aemo/exceptions/invalid_nmi_allocation_type'
 
 # AEMO Module to encapsulate all AEMO classes
 module AEMO

data/lib/data/xml_to_json.rb

@@ -21,7 +21,7 @@ CSV.parse(file_contents, headers: true, converters: :numeric).each do |row|
   @mlf_data[row['TNI']] ||= { location: row['Location'],
                               voltage: row['Voltage'],
                               loss_factors: [] }
-  row.headers.select { |x| x =~ /^FY\d{2}$/ }.sort.reverse.each do |fin_year|
+  row.headers.grep(/^FY\d{2}$/).sort.reverse.each do |fin_year|
     year = "20#{fin_year.match(/FY(\d{2})/)[1]}".to_i
     @mlf_data[row['TNI']][:loss_factors] << {
       start: Time.parse("#{year - 1}-07-01T00:00:00+1000"),
@@ -74,7 +74,5 @@ end
     output_data[code] << output_data_instance
   end
 
-  File.open(File.join(@path, output_file), 'w') do |write_file|
-    write_file.write(output_data.to_json)
-  end
+  File.write(File.join(@path, output_file), output_data.to_json)
 end

data/spec/aemo_spec.rb

@@ -1,10 +1,3 @@
 # frozen_string_literal: true
 
 require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
-
-describe AEMO do
-  before(:each) do
-    @klass = Class.new
-    @klass.instance_eval { include AEMO }
-  end
-end

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

@@ -8,42 +8,60 @@ describe AEMO::Market::Interval do
       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')
+    before do
+      @interval = described_class.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 do
+        described_class.new('2016-03-01T00:30:00', 'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23, 'RRP' => 76.54,
+                                                   'PERIODTYPE' => 'TRADING')
+      end.not_to raise_error
     end
+
     it 'has a trailing datetime' do
       expect(@interval.datetime).to eq(Time.parse('2016-03-01T00:30:00+1000'))
     end
+
     it 'has a leading datetime' do
-      expect(@interval.datetime(false)).to eq(Time.parse('2016-03-01T00:00:00+1000'))
+      expect(@interval.datetime(trailing_edge: false)).to eq(Time.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(Time.parse('2016-03-01T00:25:00+1000'))
+      @interval = described_class.new('2016-03-01T00:30:00', 'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23,
+                                                             'RRP' => 76.54, 'PERIODTYPE' => '')
+      expect(@interval.datetime(trailing_edge: false)).to eq(Time.parse('2016-03-01T00:25:00+1000'))
     end
+
     it 'has an interval length' do
       expect(@interval.interval_length).to eq(Time.at(300))
     end
+
     it 'is a trading interval' do
       expect(@interval.interval_type).to eq(:trading)
     end
+
     it 'is a trading interval' do
-      expect(@interval.trading?).to eq(true)
-      expect(@interval.dispatch?).to eq(false)
+      expect(@interval.trading?).to be(true)
+      expect(@interval.dispatch?).to be(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 = described_class.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.trading?).to eq(false)
-      expect(@interval.dispatch?).to eq(true)
+      @interval = described_class.new('2016-03-01T00:30:00', 'REGION' => 'NSW', 'TOTALDEMAND' => 1000.23,
+                                                             'RRP' => 76.54, 'PERIODTYPE' => '')
+      expect(@interval.trading?).to be(false)
+      expect(@interval.dispatch?).to be(true)
     end
+
     it 'has a valid value' do
       expect(@interval.value).to eq((@interval.total_demand * @interval.rrp).round(2))
     end

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

@@ -4,30 +4,32 @@ require 'spec_helper'
 
 describe AEMO::Market::Node do
   describe '.IDENTIFIERS' do
-    it 'should be an array' do
+    it 'is an array' do
       expect(AEMO::Market::Node::IDENTIFIERS).to be_instance_of(Array)
     end
   end
 
   describe 'creating a node' do
-    it 'should raise an error if invalid region' do
-      expect { AEMO::Market::Node.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 node valid' do
-      expect { AEMO::Market::Node.new('NSW') }.not_to raise_error
+
+    it 'creates if node valid' do
+      expect { described_class.new('NSW') }.not_to raise_error
     end
   end
 
   describe 'AEMO::Region instance methods' do
-    before(:each) do
-      @nsw = AEMO::Market::Node.new('NSW')
+    before do
+      @nsw = described_class.new('NSW')
     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.identifier).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.identifier).count)
       end
     end

data/spec/lib/aemo/market_spec.rb

@@ -14,25 +14,26 @@ describe AEMO::Market do
 
   describe '.current_dispatch' do
     it 'has an array of data' do
-      expect(AEMO::Market.current_dispatch('NSW').class).to eq(Array)
+      expect(described_class.current_dispatch('NSW').class).to eq(Array)
     end
   end
 
   describe '.current_trading' do
     it 'has an array of data' do
-      expect(AEMO::Market.current_trading('NSW').class).to eq(Array)
+      expect(described_class.current_trading('NSW').class).to eq(Array)
     end
   end
 
   describe '.historic_trading_by_range' do
     it 'has an array of data' do
-      expect(AEMO::Market.historic_trading_by_range('NSW', Date.parse('2015-01-01'), Date.parse('2015-02-28')).class).to eq(Array)
+      expect(described_class.historic_trading_by_range('NSW', Date.parse('2015-01-01'),
+                                                       Date.parse('2015-02-28')).class).to eq(Array)
     end
   end
 
   describe '.historic_trading' do
     it 'has an array of data' do
-      expect(AEMO::Market.historic_trading('NSW', 2015, 1).class).to eq(Array)
+      expect(described_class.historic_trading('NSW', 2015, 1).class).to eq(Array)
     end
   end
 end

data/spec/lib/aemo/meter_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe AEMO::Meter do
   describe 'instance methods' do
     it 'creates a new instance' do
-      expect(AEMO::Meter.new).to be_a AEMO::Meter
+      expect(described_class.new).to be_a described_class
     end
 
     it 'can be initialized from MSATS mumbo jumbo' do
       AEMO::MSATS.authorize('ER', 'ER', 'ER')
       nmi_detail_query = AEMO::MSATS.nmi_detail('4001234567')
       meter = nmi_detail_query['MeterRegister']['Meter'].first
-      expect(AEMO::Meter.from_hash(meter)).to be_a AEMO::Meter
+      expect(described_class.from_hash(meter)).to be_a described_class
     end
   end
 end