firebrew 0.1.0

data/spec/firebrew/entity_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+module Firebrew
+  class EntityTest1
+    include Entity
+    entity_attr :value1, :value2
+    def initialize(params={})
+      params.each{|(k,v)| self.send("#{k}=", v) }
+    end
+  end
+  
+  class EntityTest2
+    include Entity
+    entity_attr :value3, :value4
+  end
+  
+  class EntityTest1Ex < EntityTest1
+    entity_attr :value5, :value6
+  end
+  
+  describe Firebrew::Entity do
+    describe '::attributes()' do
+      describe 'EntityTest1(value1, value2)' do
+        it { expect(EntityTest1.attributes).to eq([:value1, :value2]) }
+      end
+      
+      describe 'EntityTest2(value3, value4)' do
+        it { expect(EntityTest2.attributes).to eq([:value3, :value4]) }
+      end
+      
+      describe 'EntityTest1Ex(value1, value2, value5, value6)' do
+        it { expect(EntityTest1Ex.attributes).to eq([:value1, :value2, :value5, :value6]) }
+      end
+    end
+    
+    describe '::entity_attr(*attrs)' do
+      subject do
+        Class.new do
+          include Entity
+        end
+      end
+      
+      it 'should add the `attrs`' do
+        expect(subject.entity_attr(:attr1, :attr2)).to eq([:attr1, :attr2])
+      end
+      
+      context 'when the `attrs` was already existed' do
+        it 'should add attributes which not exist in the `::attributes`' do
+          subject.entity_attr(:attr1)
+          expect(subject.entity_attr(:attr1, :attr2)).to eq([:attr2])
+        end
+      end
+      
+      context 'when the `attrs` contain duplicate values' do
+        it 'should add attributes which not contain duplicate values' do
+          expect(subject.entity_attr(:attr1, :attr2, :attr2)).to eq([:attr1, :attr2])
+        end
+      end
+    end
+    
+    describe '#==(rop)' do
+      context 'when `self` equaled `rop`' do
+        it do
+          a = EntityTest1.new(value1: 1, value2: 2)
+          b = EntityTest1.new(value1: 1, value2: 2)
+          expect(a == b).to be_truthy
+        end
+      end
+      
+      context 'when `self` not equaled `rop`' do
+        it do
+          a = EntityTest1.new(value1: 1, value2: 2)
+          b = EntityTest1.new(value1: 3, value2: 2)
+          expect(a == b).to be_falsy
+        end
+      end
+    end
+  end
+end

data/spec/firebrew/firefox/command_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Firebrew::Firefox
+  describe Command do
+    subject do
+      Command.new(self.config, self.executer)
+    end
+    
+    let(:config){Firebrew::Runner.default_config}
+    let(:executer){Command::Executer.new}
+    
+    context 'when the indicated firefox command by the `config[:firefox]` not existed' do
+      let(:config){super().merge firefox: 'firefox/not/existed/path'}
+      it { expect{subject}.to raise_error(Firebrew::FirefoxCommandError) }
+    end
+    
+    context 'when the indicated command by the `config[:firefox]` was not firefox' do
+      let(:executer) do
+        double('executer', exec: ['Other program', 0])
+      end
+      it { expect{subject}.to raise_error(Firebrew::FirefoxCommandError) }
+      
+      describe 'command status' do
+        let(:executer) do
+          double('executer', exec: ['Fake Mozilla Firefox', 1])
+        end
+        it { expect{subject}.to raise_error(Firebrew::FirefoxCommandError) }
+      end
+    end
+    
+    describe '#version()' do
+      subject { super().version }
+      let(:executer) do
+        double('executer', exec: ['Mozilla Firefox 30.0', 0])
+      end
+      it { is_expected.to eq('30.0') }
+    end
+  end
+end

data/spec/firebrew/firefox/extension_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+require 'fileutils'
+
+module Firebrew::Firefox
+  describe Firebrew::Firefox::Extension do
+    let(:manager) do
+      Extension::Manager.new(
+        profile: Profile.new(
+          path: './tmp'
+        )
+      )
+    end
+    
+    let(:extensions){[
+      Extension.new({
+        name: 'Japanese Language Pack',
+        guid: 'langpack-ja@firefox.mozilla.org',
+        version: '30.0',
+        uri: './tmp/extensions/langpack-ja@firefox.mozilla.org.xpi'
+      }, self.manager),
+      Extension.new({
+        name: 'Vimperator',
+        guid: 'vimperator@mozdev.org',
+        version: '3.8.2',
+        uri: './tmp/extensions/vimperator@mozdev.org.xpi'
+      }, self.manager)
+    ]}
+    
+    before do
+      FileUtils.cp('./spec/fixtures/firefox/extension/extensions.v16.json', './tmp/extensions.json')
+    end
+    
+    describe :Manager do
+      subject { self.instance }
+      let(:instance){self.manager}
+      
+      describe '#all()' do
+        subject { self.instance.all }
+        
+        it { is_expected.to be_instance_of(Array) }
+        it { expect(subject.size).to eq(2) }
+        
+        it 'should construct' do
+          expect(subject[0]).to eq(self.extensions[0])
+          expect(subject[1]).to eq(self.extensions[1])
+        end
+        
+        context 'when not existed `extension.json`' do
+          before {FileUtils.rm_f './tmp/extensions.json'}
+          it { expect{subject}.to raise_error(Firebrew::ExtensionsFileNotFoundError) }
+        end
+      end
+      
+      describe '#find(name)' do
+        subject {super().find self.name}
+        let(:name){self.extensions[1].name}
+        
+        it 'should find' do
+          is_expected.to eq(self.extensions[1])
+        end
+        
+        context 'when the extension corresponding to the `name` not existed' do
+          let(:name){'hoge'}
+          it { is_expected.to be_nil }
+        end
+      end
+      
+      describe '#find!(name)' do
+        subject {super().find! self.name}
+        let(:name){self.extensions[1].name}
+        
+        it { expect{subject}.to_not raise_error }
+        it 'should find' do
+          is_expected.to eq(self.extensions[1])
+        end
+        
+        context 'when the extension corresponding to the `name` not existed' do
+          let(:name){'hoge'}
+          it { expect{subject}.to raise_error(Firebrew::ExtensionNotFoundError) }
+        end
+      end
+      
+      describe '#install(extension)' do
+        before { self.instance.install(self.extension) }
+        
+        let(:extension) do
+          Extension.new({
+            guid: 'hoge@example.org',
+            uri: './spec/fixtures/amo_api/search/base.xml'
+          }, self.manager)
+        end
+        
+        it 'should copy the `path/to/profile/extensions/guid.xpi`' do
+          path = File.join(self.instance.profile.path, 'extensions/%s.xpi' % self.extension.guid)
+          expect(File.exists? path).to be_truthy
+        end
+        
+        it 'should add the `extension` extension' do
+          all = self.instance.all
+          extension = self.extension
+          extension.uri = './tmp/extensions/hoge@example.org.xpi'
+          expect(all.size).to eq(3)
+          expect(all[0]).to eq(self.extensions[0])
+          expect(all[1]).to eq(self.extensions[1])
+          expect(all[2]).to eq(self.extension)
+        end
+      end
+      
+      describe '#uninstall(extension)' do
+        let(:extension) do
+          Extension.new({
+            guid: 'hoge@example.org',
+            uri: './tmp/extensions/hoge@example.org.xpi'
+          }, self.manager)
+        end
+        
+        before do
+          FileUtils.cp('./spec/fixtures/firefox/extension/extensions_added_hoge.v16.json', './tmp/extensions.json')
+          File.write self.extension.uri, ''
+          self.manager.uninstall(self.extension)
+        end
+        
+        it 'should remove the `extension` file' do
+          expect(File.exists? self.extension.uri).to be_falsey
+        end
+        
+        it 'should remove the `extension` extension' do
+          all = self.instance.all
+          expect(all.size).to eq(2)
+          expect(all[0]).to eq(self.extensions[0])
+          expect(all[1]).to eq(self.extensions[1])
+        end
+      end
+    end
+    
+    describe 'instance' do
+      subject {self.instance}
+      let(:instance){self.extensions[1]}
+      
+      before do
+        open(self.instance.uri,'w'){|o| o.write self.instance.name}
+      end
+      
+      after do
+        FileUtils.rm_f self.instance.uri
+      end
+      
+      describe '#delete()' do
+        before do
+          self.instance().delete
+        end
+        
+        it 'should not existed this file' do
+          expect(File.exists? self.instance.uri).to be_falsey
+        end
+      end
+    end
+  end
+end

data/spec/firebrew/firefox/profile_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Firebrew::Firefox
+  describe Firebrew::Firefox::Profile do
+    describe :Manager do
+      subject do
+        Profile::Manager.new(
+          base_dir: self.base_dir,
+          data_file: self.data_file
+        )
+      end
+      
+      let(:base_dir){'./spec/fixtures/firefox/profile'}
+      let(:data_file){'base.ini'}
+      
+      context 'when "profiles.ini" not existed' do
+        let(:base_dir){'not/existed/directory'}
+        let(:data_file){'not_found.ini'}
+        it { expect{subject}.to raise_error(Firebrew::ProfilesFileNotFoundError) }
+      end
+      
+      describe '#all()' do
+        subject { super().all }
+        it { expect(subject.size).to eq(3) }
+        
+        it 'should construct records' do
+          expect(subject[0].name).to eq('default')
+          expect(subject[0].path).to eq(File.expand_path File.join(self.base_dir, 'Profiles/abcd.default'))
+          expect(subject[0].is_default).to be_truthy
+          
+          expect(subject[1].name).to eq('other_profile')
+          expect(subject[1].path).to eq(File.expand_path File.join(self.base_dir, 'Profiles/efgh.other_profile'))
+          expect(subject[1].is_default).to be_falsey
+          
+          expect(subject[2].name).to eq('abs_profile')
+          expect(subject[2].path).to eq('/path/to/abs_profile')
+          expect(subject[2].is_default).to be_falsey
+        end
+        
+        context 'when profiles were empty' do
+          let(:data_file){'empty.ini'}
+          it { is_expected.to be_empty }
+        end
+      end
+      
+      describe '#find(name)' do
+        subject { super().find(self.name) }
+        let(:name){'other_profile'}
+        it { expect(subject.name).to eq('other_profile') }
+        
+        context 'when not existed the `name` in the profiles.' do
+          let(:name){'not_existed_profile_name'}
+          it { is_expected.to be_nil }
+        end
+      end
+      
+      describe '#find!(name)' do
+        subject {super().find! self.name}
+        let(:name){'other_profile'}
+        it { expect{subject}.to_not raise_error}
+        
+        context 'when not existed the `name` in the profiles.' do
+          let(:name){'not_existed_profile_name'}
+          it { expect{subject}.to raise_error(Firebrew::ProfileNotFoundError) }
+        end
+      end
+    end
+  end
+end

data/spec/firebrew/runner_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+module Firebrew
+  describe Firebrew::Runner do
+    describe '::default_config(platform)' do
+      subject do
+        Runner.default_config(self.platform)
+      end
+      
+      let(:platform){RUBY_PLATFORM}
+      
+      before do
+        ENV['FIREBREW_FIREFOX_PROFILE_BASE_DIR'] = nil
+        ENV['FIREBREW_FIREFOX_PROFILE'] = nil
+        ENV['FIREBREW_FIREFOX'] = nil
+      end
+      
+      context 'when the `platform` was "MacOS"' do
+        let(:platform){'x86_64-darwin13.0'}
+        it do
+          is_expected.to eq(
+            base_dir: '~/Library/Application Support/Firefox',
+            firefox: '/Applications/Firefox.app/Contents/MacOS/firefox-bin',
+            profile: 'default'
+          )
+        end
+      end
+      
+      context 'when the `platform` was "Linux"' do
+        let(:platform){'x86_64-linux'}
+        it do
+          is_expected.to eq(
+            base_dir: '~/.mozilla/firefox',
+            firefox: '/usr/bin/firefox',
+            profile: 'default'
+          )
+        end
+      end
+      
+      context 'when the `platform` was "Windows 7 x86_64"' do
+        let(:platform){'x64-mingw32'}
+        it do
+          is_expected.to eq(
+            base_dir: '~/AppData/Roming/Mozilla/Firefox',
+            firefox: 'C:/Program Files (x86)/Mozilla Firefox/firefox.exe',
+            profile: 'default'
+          )
+        end
+      end
+      
+      context 'when set environment variables' do
+        before do
+          ENV['FIREBREW_FIREFOX_PROFILE_BASE_DIR'] = 'path/to/profile_base_directory'
+          ENV['FIREBREW_FIREFOX_PROFILE'] = 'profile-name'
+          ENV['FIREBREW_FIREFOX'] = 'path/to/firefox'
+        end
+        
+        after do
+          ENV['FIREBREW_FIREFOX_PROFILE_BASE_DIR'] = nil
+          ENV['FIREBREW_FIREFOX_PROFILE'] = nil
+          ENV['FIREBREW_FIREFOX'] = nil
+        end
+        
+        it do
+          is_expected.to eq(
+            base_dir: 'path/to/profile_base_directory',
+            firefox: 'path/to/firefox',
+            profile: 'profile-name'
+          )
+        end
+      end
+    end
+    
+    describe :Instance do
+      subject {self.instance}
+      
+      let(:instance) do
+        Runner.new(
+          base_dir: './tmp',
+          data_file: 'profiles.ini',
+          firefox: './spec/double/firefox.rb'
+        )
+      end
+      
+      let(:search_params){{term: 'hoge', version: '30.0', max: 1}}
+      
+      before do
+        FileUtils.cp './spec/fixtures/firefox/profile/base.ini', './tmp/profiles.ini'
+        response = File.read("./spec/fixtures/amo_api/search/base.xml")
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get AmoApi::Search.path(self.search_params), {}, response
+        end
+      end
+      
+      after do
+        FileUtils.rm_f './tmp/*'
+        ActiveResource::HttpMock.reset!
+      end
+      
+      describe '#install(params)' do
+        subject do
+          extensions_double = double('extensions', install: nil, find: nil)
+          self.instance.profile = double('profile', extensions: extensions_double)
+          self.instance.install(self.search_params)
+        end
+        
+        it { expect{subject}.to_not raise_error }
+        
+        context 'when the `params[:term]` existed' do
+          subject do
+            extensions_double = double('extensions', install: nil, find: Firefox::BasicExtension.new)
+            self.instance.profile = double('profile', extensions: extensions_double)
+            self.instance.install(self.search_params)
+          end
+          
+          it { expect{subject}.to raise_error(Firebrew::OperationAlreadyCompletedError) }
+        end
+      end
+      
+      describe '#uninstall(params)' do
+        subject do
+          extensions_double = double('extensions', find!: double('ext', delete: nil))
+          self.instance.profile = double('profile', extensions: extensions_double)
+          self.instance.uninstall(term: 'not-existed-extension')
+        end
+        
+        it { expect{subject}.to_not raise_error }
+        
+        context 'when the `params[:term]` not existed' do
+          subject do
+            extensions_double = double('extensions')
+            allow(extensions_double).to receive(:find!).and_raise(Firebrew::ExtensionNotFoundError)
+            self.instance.profile = double('profile', extensions: extensions_double)
+            self.instance.uninstall(term: 'not-existed-extension')
+          end
+          
+          it { expect{subject}.to raise_error(Firebrew::OperationAlreadyCompletedError) }
+        end
+      end
+    end
+  end
+end