battman 0.0.1

data/spec/lib/battman/acpi_battery_spec.rb

@@ -0,0 +1,232 @@
+require 'battman/acpi_battery'
+
+module Battman
+
+  describe AcpiBattery do
+    it 'is a subclass of Battery' do
+      expect(AcpiBattery.new).to be_a Battery
+    end
+
+    describe '.new' do
+      it 'accepts an precision option and sets the corresponding instance variable' do
+        battery = AcpiBattery.new(0, precision: 100)
+
+        expect(battery.instance_variable_get(:@precision)).to eq 100
+      end
+
+      it 'sets precision to 1000 by default' do
+        expect(AcpiBattery.new.instance_variable_get(:@precision)).to eq 1000
+      end
+    end
+
+    describe '#path' do
+
+      let(:path_prefix) { '/sys/class/power_supply' }
+
+      it 'builds the path for a smapi battery with the correct index' do
+        battery = AcpiBattery.new
+
+        expect(battery.path).to eq File.join(path_prefix, 'BAT0')
+
+        battery = AcpiBattery.new(1)
+
+        expect(battery.path).to eq File.join(path_prefix, 'BAT1')
+      end
+
+      it 'sets the corresponding instance variable' do
+        battery = AcpiBattery.new
+        path = battery.path
+
+        expect(battery.instance_variable_get(:@path)).to eq path
+      end
+    end
+
+    let(:battery) { AcpiBattery.new }
+
+    before(:each) do
+      allow(File).to receive(:join).and_call_original
+    end
+
+    describe '#remaining_percent' do
+
+      let(:energy_full_file) { File.join(battery.path, 'energy_full') }
+      let(:energy_now_file) { File.join(battery.path, 'energy_now') }
+
+      before(:each) do
+        allow(File).to receive(:read).with(energy_full_file).and_return("1000\n")
+        allow(File).to receive(:read).with(energy_now_file).and_return("100\n")
+      end
+
+      it 'reads the value from the correct files' do
+        battery.remaining_percent
+
+        expect(File).to have_received(:read).with(energy_full_file)
+        expect(File).to have_received(:read).with(energy_now_file)
+      end
+
+      it 'calculates the percentage from the read file contents' do
+        expect(battery.remaining_percent).to eq 10
+      end
+
+    end
+
+    describe '#power' do
+
+      let(:power_file) { File.join(battery.path, 'power_now') }
+
+      it 'reads the value from the correct file' do
+        allow(File).to receive(:read).with(power_file).and_return("1000000\n")
+        allow(battery).to receive(:state).and_return(:charging)
+        battery.power
+
+        expect(File).to have_received(:read).with(power_file)
+      end
+
+      it 'returns the power used in watt' do
+        allow(File).to receive(:read).with(power_file).and_return("1000000\n")
+        allow(battery).to receive(:state).and_return(:charging)
+
+        expect(battery.power).to eq(1.0)
+      end
+
+      it 'returns a negative value if state is :discharging' do
+        allow(File).to receive(:read).with(power_file).and_return("1000000\n")
+        allow(battery).to receive(:state).and_return(:discharging)
+
+        expect(battery.power).to be < 0
+      end
+
+      it 'returns a positive value if state is either :charging or :idle' do
+        allow(File).to receive(:read).with(power_file).and_return("1000000\n")
+        allow(battery).to receive(:state).and_return(:charging)
+
+        expect(battery.power).to be >= 0
+
+        allow(battery).to receive(:state).and_return(:idle)
+
+        expect(battery.power).to be >= 0
+      end
+
+    end
+
+    describe "#state" do
+      let(:state_file) { File.join(battery.path, 'status') }
+
+      it 'reads the state from the correct file' do
+        allow(File).to receive(:read).with(state_file).and_return("Discharging\n")
+        battery.state
+
+        expect(File).to have_received(:read).with(state_file)
+      end
+
+      it 'returns the correct state as a symbol' do
+        allow(File).to receive(:read).with(state_file).and_return("Discharging\n")
+
+        expect(battery.state).to eq :discharging
+      end
+
+      it 'returns :idle if state read from file is Unknown' do
+        allow(File).to receive(:read).with(state_file).and_return("Unknown\n")
+
+        expect(battery.state).to eq :idle
+      end
+    end
+
+    describe "#remaining_energy" do
+      let(:energy_file) { File.join(battery.path, 'energy_now') }
+
+      it 'reads the value from the correct file' do
+        allow(File).to receive(:read).with(energy_file).and_return("100000000\n")
+        battery.remaining_energy
+
+        expect(File).to have_received(:read).with(energy_file)
+      end
+
+      it 'returns the remaining energy in Wh' do
+        allow(File).to receive(:read).with(energy_file).and_return("100000000\n")
+
+        expect(battery.remaining_energy).to eq 100.0
+      end
+    end
+
+    describe '#remaining_running_time' do
+      it 'calculates the value from the current power and remaining energy' do
+        allow(battery).to receive(:state).and_return(:discharging)
+        allow(battery).to receive(:power).and_return(10.0)
+        allow(battery).to receive(:remaining_energy).and_return(100.0)
+        battery.remaining_running_time
+
+        expect(battery).to have_received(:power)
+        expect(battery).to have_received(:remaining_energy)
+
+        expect(battery.remaining_running_time).to eq 600
+      end
+
+      it 'raises a WrongStateError if the battery is not discharging' do
+        allow(battery).to receive(:power).and_return(10.0)
+        allow(battery).to receive(:remaining_energy).and_return(100.0)
+
+        allow(battery).to receive(:state).and_return(:discharging)
+        battery.remaining_running_time
+
+        allow(battery).to receive(:state).and_return(:idle)
+
+        expect { battery.remaining_running_time }.to raise_error(WrongStateError)
+
+        allow(battery).to receive(:state).and_return(:charging)
+
+        expect { battery.remaining_running_time }.to raise_error(WrongStateError)
+      end
+
+    end
+
+    describe "#full_energy" do
+      let(:energy_file) { File.join(battery.path, 'energy_full') }
+
+      it 'reads the value from the correct file' do
+        allow(File).to receive(:read).with(energy_file).and_return("100000000\n")
+        battery.full_energy
+
+        expect(File).to have_received(:read).with(energy_file)
+      end
+
+      it 'returns the remaining energy in Wh' do
+        allow(File).to receive(:read).with(energy_file).and_return("100000000\n")
+
+        expect(battery.full_energy).to eq 100.0
+      end
+    end
+
+    describe '#remaining_charging_time' do
+      it 'calculates the value from the current power and remaining energy' do
+        allow(battery).to receive(:state).and_return(:charging)
+        allow(battery).to receive(:power).and_return(10.0)
+        allow(battery).to receive(:remaining_energy).and_return(90.0)
+        allow(battery).to receive(:full_energy).and_return(100.0)
+        battery.remaining_charging_time
+
+        expect(battery).to have_received(:power)
+        expect(battery).to have_received(:remaining_energy)
+
+        expect(battery.remaining_charging_time).to eq 60.0
+      end
+
+      it 'raises a WrongStateError if the battery is not charging' do
+        allow(battery).to receive(:remaining_energy).and_return(90.0)
+        allow(battery).to receive(:power).and_return(10.0)
+        allow(battery).to receive(:full_energy).and_return(100.0)
+
+        allow(battery).to receive(:state).and_return(:charging)
+        battery.remaining_charging_time
+
+        allow(battery).to receive(:state).and_return(:discharging)
+
+        expect { battery.remaining_charging_time }.to raise_error(WrongStateError)
+
+        allow(battery).to receive(:state).and_return(:idle)
+
+        expect { battery.remaining_charging_time }.to raise_error(WrongStateError)
+      end
+    end
+  end
+end

data/spec/lib/battman/battery_spec.rb

@@ -0,0 +1,111 @@
+require 'battman/battery'
+module Battman
+  describe Battery do
+
+    describe '.new' do
+
+      it 'throws an AbstractError if directly instantiated' do
+        expect { Battery.new }.to raise_error AbstractError
+      end
+
+      let(:subclass) { Class.new(Battery) }
+
+      it 'allows instantiation of subclasses' do
+        subclass.new
+      end
+
+      it 'accepts an index and sets the corresponding instance variable' do
+        battery = subclass.new(1)
+
+        expect(battery.instance_variable_get(:@index)).to eq 1
+      end
+
+      it 'sets index to 0 by default' do
+        battery = subclass.new
+
+        expect(battery.instance_variable_get(:@index)).to eq 0
+      end
+
+    end
+
+    let(:battery) { Class.new(Battery).new }
+
+    [:remaining_percent, :power, :remaining_running_time,
+     :remaining_charging_time, :state, :remaining_energy,
+     :full_energy].each do |method|
+
+      describe "##{method}" do
+
+        it 'throws an NotImplementedError' do
+          expect { battery.send(method) }.to raise_error NotImplementedError
+        end
+      end
+    end
+
+
+     describe '#power_in' do
+       it 'requires a unit argument' do
+         expect { battery.power_in }.to raise_error(ArgumentError)
+       end
+
+       it 'only accepts units from CONVERSIONS[:power]' do
+         expect { battery.power_in(:unsupported_unit) }.to raise_error(UnsupportedUnitError)
+
+         allow(battery).to receive(:power).and_return(10.0)
+         battery.power_in(Battery::CONVERSIONS[:power].keys.sample)
+       end
+
+       it 'converts the power from watts to the given unit' do
+         allow(battery).to receive(:power).and_return(10.0)
+
+         expect(battery.power_in(:watts)).to eq 10.0
+         expect(battery.power_in(:milliwatts)).to eq 10_000.0
+       end
+     end
+
+     [:remaining_running_time, :remaining_charging_time].each do |method|
+       describe "#{method}_in" do
+         it 'requires a unit argument' do
+           expect { battery.send(:"#{method}_in") }.to raise_error(ArgumentError)
+         end
+
+         it 'only accepts units from CONVERSIONS[:time]' do
+           expect { battery.send(:"#{method}_in", :unsupported_unit) }.to raise_error(UnsupportedUnitError)
+
+           allow(battery).to receive(method).and_return(10.0)
+           battery.send(:"#{method}_in", Battery::CONVERSIONS[:time].keys.sample)
+         end
+
+         it 'converts the time from seconds to the given unit' do
+           allow(battery).to receive(method).and_return(3600.0)
+
+           expect(battery.send(:"#{method}_in", :seconds)).to eq 3600.0
+           expect(battery.send(:"#{method}_in", :minutes)).to eq 60.0
+           expect(battery.send(:"#{method}_in", :hours)).to eq 1.0
+         end
+       end
+     end
+
+     [:remaining_energy, :full_energy].each do |method|
+       describe "#{method}_in" do
+         it 'requires a unit argument' do
+           expect { battery.send(:"#{method}_in") }.to raise_error(ArgumentError)
+         end
+
+         it 'only accepts units from CONVERSIONS[:energy]' do
+           expect { battery.send(:"#{method}_in", :unsupported_unit) }.to raise_error(UnsupportedUnitError)
+
+           allow(battery).to receive(method).and_return(10.0)
+           battery.send(:"#{method}_in", Battery::CONVERSIONS[:energy].keys.sample)
+         end
+
+         it 'converts the time from watt hours to the given unit' do
+           allow(battery).to receive(method).and_return(10.0)
+
+           expect(battery.send(:"#{method}_in", :watt_hours)).to eq 10.0
+           expect(battery.send(:"#{method}_in", :milliwatt_hours)).to eq 10_000.0
+         end
+       end
+     end
+  end
+end

data/spec/lib/battman/dsl/every_block_spec.rb

@@ -0,0 +1,62 @@
+require 'battman/dsl/every_block'
+
+module Battman
+  module DSL
+    describe EveryBlock do
+
+      describe '#check' do
+
+        let(:dsl) { double('DSL') }
+        let(:battery) { double('Battery') }
+        let(:state) { EveryBlock.new(dsl, battery, 10) }
+
+        before(:each) do
+          allow(battery).to receive(:power_in).with(:milliwatts)
+          allow(battery).to receive(:remaining_percent)
+          allow(dsl).to receive(:register)
+        end
+
+        it 'expects a battery attribute and a block' do
+          expect { state.check }.to raise_error(ArgumentError)
+          expect { state.check(:remaining_percent) }.to raise_error(ArgumentError)
+          state.check(:remaining_percent) {}
+        end
+
+        it 'allows additional arguments to pass methods' do
+          state.check(:power_in, :milliwatts) {}
+        end
+
+        it 'correctly registers a block on the dsl instance' do
+          task_was_called = false
+          value_passed = nil
+          last_value_passed = nil
+          task = Proc.new do |value, last_value|
+            task_was_called = true
+            value_passed = value
+            last_value_passed = last_value
+          end
+
+          expect(dsl).to receive(:register) do |interval, block|
+            expect(interval).to eq 10
+
+            expect(battery).to receive(:power_in).with(:milliwatts).and_return(10_000.0)
+            block.call
+
+            expect(task_was_called)
+            expect(value_passed).to eq 10_000.0
+            expect(last_value_passed).to be nil
+
+            expect(battery).to receive(:power_in).with(:milliwatts).and_return(9_000.0)
+            block.call
+
+            expect(value_passed).to eq 9_000.0
+            expect(last_value_passed).to eq 10_000.0
+          end
+
+          state.check(:power_in, :milliwatts, &task)
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/battman/dsl/watch_block_spec.rb

@@ -0,0 +1,27 @@
+require 'battman/dsl/watch_block'
+
+module Battman
+  module DSL
+    describe WatchBlock do
+      let(:dsl) { double('DSL') }
+      let(:battery) { double('Battery') }
+      let(:watcher) { WatchBlock.new(dsl, battery) }
+
+      describe '#every' do
+        it 'expects an interval in seconds and a block' do
+          expect { watcher.every }.to raise_error(ArgumentError)
+          expect { watcher.every(10) }.to raise_error(ArgumentError)
+
+          watcher.every(10) {}
+        end
+
+        it 'yields an object that responds to check' do
+          expect {|b| watcher.every(10, &b) }.to yield_with_args do |arg|
+            expect(arg).to respond_to(:check)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/battman/dsl_spec.rb

@@ -0,0 +1,137 @@
+require 'battman/dsl'
+require 'battman/smapi_battery'
+require 'active_support/core_ext/numeric/time'
+
+module Battman
+  describe DSL do
+
+    let(:dsl) { Class.new { include DSL }.new }
+
+    describe '.new' do
+      it 'initializes @blocks correctly' do
+        blocks = dsl.instance_variable_get(:@blocks)
+        expect(blocks).not_to be nil
+        expect(blocks[2]).to eq []
+
+        blocks[4] << :foo
+        blocks[4] << :bar
+        expect(blocks[4]).to eq [:foo, :bar]
+      end
+
+      it 'initializes @intervals_due correctly' do
+        intervals_due = dsl.instance_variable_get(:@intervals_due)
+
+        expect(intervals_due[1]).to eq 0
+        expect(intervals_due[:anything]).to eq 0
+      end
+
+      it 'yields self if given a block' do
+        expect {|b| Class.new { include DSL }.new(&b) }.to yield_with_args(DSL)
+      end
+    end
+
+    describe '#watch' do
+
+      it 'instantiates a battery of given type' do
+        expect(SmapiBattery).to receive(:new)
+
+        dsl.watch(:smapi) {}
+      end
+
+      it 'expects a valid type and a block' do
+        expect { dsl.watch }.to raise_error(ArgumentError)
+        expect { dsl.watch(:type) }.to raise_error(ArgumentError)
+        expect { dsl.watch(:invalid_type) {} }.to raise_error(LoadError)
+
+        dsl.watch(:smapi) {}
+      end
+
+      it 'yields a WatchBlock' do
+        expect {|b| dsl.watch(:smapi, &b) }.to yield_with_args(DSL::WatchBlock)
+      end
+
+    end
+
+    describe '#register' do
+
+      it 'adds a given block to the blocks hash' do
+        first_block = Proc.new {}
+        second_block = Proc.new {}
+        dsl.register(1, first_block)
+        dsl.register(1, second_block)
+
+        expect(dsl.instance_variable_get(:@blocks)[1]).to eq [first_block, second_block]
+      end
+
+      it 'sets the greatest common interval correctly' do
+        dsl.register(4, Proc.new {})
+        expect(dsl.instance_variable_get(:@greatest_common_interval)).to eq 4
+
+        dsl.register(8, Proc.new {})
+        expect(dsl.instance_variable_get(:@greatest_common_interval)).to eq 4
+
+        dsl.register(10, Proc.new {})
+        expect(dsl.instance_variable_get(:@greatest_common_interval)).to eq 2
+      end
+
+    end
+
+    describe '#run_once' do
+      let(:blocks) do
+        blocks = Hash.new {|hash, key| hash[key] = []}
+        3.times do |i|
+          block = double('proc')
+          allow(block).to receive(:call)
+          blocks[2**(i+1)] << block
+        end
+
+        blocks
+      end
+
+      let(:greatest_common_interval) { blocks.keys.inject(:gcd) }
+
+      before(:each) do
+        dsl.instance_variable_set(:@blocks, blocks)
+        dsl.instance_variable_set(:@greatest_common_interval, greatest_common_interval)
+      end
+
+      it 'calls all registered blocks on the first run' do
+        blocks.values.inject(&:+).each do |block|
+          expect(block).to receive(:call).once
+        end
+
+        dsl.run_once
+      end
+
+      it 'sets the correct schedules for blocks in @intervals_due' do
+        expected_schedule = {}
+        blocks.keys.each do |interval|
+          expected_schedule[interval] = interval
+        end
+
+        dsl.run_once
+        expect(dsl.instance_variable_get(:@intervals_due)).to eq expected_schedule
+      end
+
+      it 'calls only scheduled blocks on consecutive runs' do
+        dsl.run_once
+        dsl.run_once
+
+        blocks[greatest_common_interval].each do |block|
+          expect(block).to have_received(:call).twice
+        end
+
+        dsl.run_once
+
+        blocks[greatest_common_interval].each do |block|
+          expect(block).to have_received(:call).exactly(3).times
+        end
+
+        blocks[greatest_common_interval * 2].each do |block|
+          expect(block).to have_received(:call).twice
+        end
+      end
+    end
+
+  end
+end