robust_excel_ole 1.1.4 → 1.1.5

data/spec/ruby1.8.6_rspec2.14/sheet_spec.rb

@@ -0,0 +1,663 @@
+# -*- coding: utf-8 -*-
+
+require File.join(File.dirname(__FILE__), './spec_helper')
+
+$VERBOSE = nil
+
+include RobustExcelOle
+include General
+
+describe Sheet do
+ 
+  before(:all) do
+    excel = Excel.new(:reuse => true)
+    open_books = excel == nil ? 0 : excel.Workbooks.Count
+    puts "*** open books *** : #{open_books}" if open_books > 0
+    Excel.kill_all
+  end 
+
+  before do
+    @dir = create_tmpdir
+    @simple_file = @dir + '/workbook.xls'
+    @protected_file = @dir + '/protected_sheet.xls'
+    @blank_file = @dir + '/book_with_blank.xls'
+    @merge_file = @dir + '/merge_cells.xls'
+    @book = Book.open(@simple_file)
+    @sheet = @book.sheet(1)
+  end
+
+  after do
+    @book.close(:if_unsaved => :forget)
+    Excel.kill_all
+    rm_tmp(@dir)
+  end
+
+  describe ".initialize" do
+    context "when open sheet protected(with password is 'protect')" do
+      before do
+        @key_sender = IO.popen  'ruby "' + File.join(File.dirname(__FILE__), '/helpers/key_sender.rb') + '" "Microsoft Office Excel" '  , "w"
+        @book_protect = Book.open(@protected_file, :visible => true, :read_only => true, :force_excel => :new)
+        @book_protect.excel.displayalerts = false
+        @key_sender.puts "{p}{r}{o}{t}{e}{c}{t}{enter}"
+        @protected_sheet = @book_protect.sheet('protect')
+      end
+
+      after do
+        @book_protect.close
+        @key_sender.close
+      end
+
+      it "should be a protected sheet" do
+        @protected_sheet.ProtectContents.should be_true
+      end
+
+      it "protected sheet can't be write" do
+        expect { @protected_sheet[1,1] = 'write' }.to raise_error
+      end
+    end
+
+  end
+
+  shared_context "sheet 'open book with blank'" do
+    before do
+      @book_with_blank = Book.open(@blank_file, :read_only => true)
+      @sheet_with_blank = @book_with_blank.sheet(1)
+    end
+
+    after do
+      @book_with_blank.close
+    end
+  end
+
+  describe "workbook" do
+    before do
+      @book = Book.open(@simple_file)
+      @sheet = @book.sheet(1)
+    end
+
+    after do
+      @book.close
+    end
+
+    it "should return workbook" do
+      @sheet.workbook.should === @book
+    end
+
+  end
+    
+  describe "access sheet name" do
+    describe "#name" do
+      it 'get sheet1 name' do
+        @sheet.name.should eq 'Sheet1'
+      end
+    end
+
+    describe "#name=" do
+      
+      it 'change sheet1 name to foo' do
+        @sheet.name = 'foo'
+        @sheet.name.should eq 'foo'
+      end
+
+      it "should raise error when adding the same name" do
+        @sheet.name = 'foo'
+        @sheet.name.should eq 'foo'
+        new_sheet = @book.add_sheet @sheet
+        expect{
+          new_sheet.name = 'foo'
+        }.to raise_error(NameAlreadyExists, /sheet name "foo" already exists/)
+      end
+    end
+  end
+
+  describe 'access cell' do
+
+    describe "#[,]" do      
+
+      context "access [1,1]" do
+
+        it { @sheet[1, 1].should be_kind_of Cell }
+        it { @sheet[1, 1].value.should eq 'foo' }
+      end
+
+      context "access [1, 1], [1, 2], [3, 1]" do
+        it "should get every values" do
+          @sheet[1, 1].value.should eq 'foo'
+          @sheet[1, 2].value.should eq 'workbook'
+          @sheet[3, 1].value.should eq 'matz'
+        end
+      end
+
+      context "supplying nil as parameter" do
+        it "should access [1,1]" do
+          @sheet[1, nil].value.should eq 'foo'
+          @sheet[nil, 1].value.should eq 'foo'
+        end
+      end
+
+    end
+
+    it "change a cell to 'bar'" do
+      @sheet[1, 1] = 'bar'
+      @sheet[1, 1].value.should eq 'bar'
+    end
+
+    it "should change a cell to nil" do
+      @sheet[1, 1] = nil
+      @sheet[1, 1].value.should eq nil
+    end
+
+    it "should raise error for bad ranges" do
+      expect{
+        @sheet[0,0]
+      }.to raise_error(RangeNotEvaluatable, "cannot read cell (0,0)")
+      expect{
+        @sheet[0,0] = "foo"
+      }.to raise_error(RangeNotEvaluatable, /cannot assign value/)
+    end
+
+    describe '#each' do
+      it "should sort line in order of column" do
+        @sheet.each_with_index do |cell, i|
+          case i
+          when 0
+            cell.value.should eq 'foo'
+          when 1
+            cell.value.should eq 'workbook'
+          when 2
+            cell.value.should eq 'sheet1'
+          when 3
+            cell.value.should eq 'foo'
+          when 4
+            cell.value.should be_nil
+          when 5
+            cell.value.should eq 'foobaaa'
+          end
+        end
+      end
+
+      context "read sheet with blank" do
+        include_context "sheet 'open book with blank'"
+
+        it 'should get from ["A1"]' do
+          @sheet_with_blank.each_with_index do |cell, i|
+            case i
+            when 5
+              cell.value.should be_nil
+            when 6
+              cell.value.should eq 'simple'
+            when 7
+              cell.value.should be_nil
+            when 8
+              cell.value.should eq 'workbook'
+            when 9
+              cell.value.should eq 'sheet1'
+            end
+          end
+        end
+      end
+
+    end
+
+    describe "#each_row" do
+      it "items should RobustExcelOle::Range" do
+        @sheet.each_row do |rows|
+          rows.should be_kind_of RobustExcelOle::Range
+        end
+      end
+
+      context "with argument 1" do
+        it 'should read from second row' do
+          @sheet.each_row(1) do |rows|
+            case rows.row
+            when 2
+              rows.values.should eq ['foo', nil, 'foobaaa']
+            when 3
+              rows.values.should eq ['matz', 'is', 'nice']
+            end
+          end
+        end
+      end
+
+      context "read sheet with blank" do
+        include_context "sheet 'open book with blank'"
+
+        it 'should get from ["A1"]' do
+          @sheet_with_blank.each_row do |rows|
+            case rows.row - 1
+            when 0
+              rows.values.should eq [nil, nil, nil, nil, nil]
+            when 1
+              rows.values.should eq [nil, 'simple', nil, 'workbook', 'sheet1']
+            when 2
+              rows.values.should eq [nil, 'foo', nil, nil, 'foobaaa']
+            when 3
+              rows.values.should eq [nil, nil, nil, nil, nil]
+            when 4
+              rows.values.should eq [nil, 'matz', nil, 'is', 'nice']
+            end
+          end
+        end
+      end
+
+    end
+
+    describe "#each_row_with_index" do
+      it "should read with index" do
+        @sheet.each_row_with_index do |rows, idx|
+          case idx
+          when 0
+            rows.values.should eq ['foo', 'workbook', 'sheet1']
+          when 1
+            rows.values.should eq ['foo', nil, 'foobaaa']
+          when 2
+            rows.values.should eq ['matz', 'is', 'nice']
+          end
+        end
+      end
+
+      context "with argument 1" do
+        it "should read from second row, index is started 0" do
+          @sheet.each_row_with_index(1) do |rows, idx|
+            case idx
+            when 0
+              rows.values.should eq ['foo', nil, 'foobaaa']
+            when 1
+              rows.values.should eq ['matz', 'is', 'nice']
+            end
+          end
+        end
+      end
+
+    end
+
+    describe "#each_column" do
+      it "items should RobustExcelOle::Range" do
+        @sheet.each_column do |columns|
+          columns.should be_kind_of RobustExcelOle::Range
+        end
+      end
+
+      context "with argument 1" do
+        it "should read from second column" do
+          @sheet.each_column(1) do |columns|
+            case columns.column
+            when 2
+              columns.values.should eq ['workbook', nil, 'is']
+            when 3
+              columns.values.should eq ['sheet1', 'foobaaa', 'nice']
+            end
+          end
+        end
+      end
+
+      context "read sheet with blank" do
+        include_context "sheet 'open book with blank'"
+
+        it 'should get from ["A1"]' do
+          @sheet_with_blank.each_column do |columns|
+            case columns.column- 1
+            when 0
+              columns.values.should eq [nil, nil, nil, nil, nil]
+            when 1
+              columns.values.should eq [nil, 'simple', 'foo', nil, 'matz']
+            when 2
+              columns.values.should eq [nil, nil, nil, nil, nil]
+            when 3
+              columns.values.should eq [nil, 'workbook', nil, nil, 'is']
+            when 4
+              columns.values.should eq [nil, 'sheet1', 'foobaaa', nil, 'nice']
+            end
+          end
+        end
+      end
+
+      context "read sheet which last cell is merged" do
+        before do
+          @book_merge_cells = Book.open(@merge_file)
+          @sheet_merge_cell = @book_merge_cells.sheet(1)
+        end
+
+        after do
+          @book_merge_cells.close
+        end
+
+        it "should get from ['A1'] to ['C2']" do
+          columns_values = []
+          @sheet_merge_cell.each_column do |columns|
+            columns_values << columns.values
+          end
+          columns_values.should eq [
+                                [nil, 'first merged', nil, 'merged'],
+                                [nil, 'first merged', 'first', 'merged'],
+                                [nil, 'first merged', 'second', 'merged'],
+                                [nil, nil, 'third', 'merged']
+                           ]
+        end
+      end
+    end
+
+    describe "#each_column_with_index" do
+      it "should read with index" do
+        @sheet.each_column_with_index do |columns, idx|
+          case idx
+          when 0
+            columns.values.should eq ['foo', 'foo', 'matz']
+          when 1
+            columns.values.should eq ['workbook', nil, 'is']
+          when 2
+            columns.values.should eq ['sheet1', 'foobaaa', 'nice']
+          end
+        end
+      end
+
+      context "with argument 1" do
+        it "should read from second column, index is started 0" do
+          @sheet.each_column_with_index(1) do |column_range, idx|
+            case idx
+            when 0
+              column_range.values.should eq ['workbook', nil, 'is']
+            when 1
+              column_range.values.should eq ['sheet1', 'foobaaa', 'nice']
+            end
+          end
+        end
+      end
+    end
+
+    describe "#row_range" do
+      context "with second argument" do
+        before do
+          @row_range = @sheet.row_range(1, 2..3)
+        end
+
+        it { @row_range.should be_kind_of RobustExcelOle::Range }
+
+        it "should get range cells of second argument" do
+          @row_range.values.should eq ['workbook', 'sheet1']
+        end
+      end
+
+      context "without second argument" do
+        before do
+          @row_range = @sheet.row_range(3)
+        end
+
+        it "should get all cells" do
+          @row_range.values.should eq ['matz', 'is', 'nice']
+        end
+      end
+
+    end
+
+    describe "#col_range" do
+      context "with second argument" do
+        before do
+          @col_range = @sheet.col_range(1, 2..3)
+        end
+
+        it { @col_range.should be_kind_of RobustExcelOle::Range }
+
+        it "should get range cells of second argument" do
+          @col_range.values.should eq ['foo', 'matz']
+        end
+      end
+
+      context "without second argument" do
+        before do
+          @col_range = @sheet.col_range(2)
+        end
+
+        it "should get all cells" do
+          @col_range.values.should eq ['workbook', nil, 'is']
+        end
+      end
+    end
+
+    describe "[], []=" do
+      before do
+        @book1 = Book.open(@dir + '/another_workbook.xls')
+        @sheet1 = @book1.sheet(1)
+      end
+
+      after do
+        @book1.close(:if_unsaved => :forget)
+      end   
+
+      it "should return value of a defined name" do
+        @sheet1["firstcell"].should == "foo"
+      end
+
+      it "should return value of a defined name" do
+        @sheet1["new"].should == "foo"         
+        @sheet1["one"].should == 1.0    
+        @sheet1["four"].should == [[1,2],[3,4]]
+        @sheet1["firstrow"].should == [[1,2]]
+      end  
+
+      it "should return value of a name with coordinates" do
+        @sheet1["A1"].should == "foo"         
+      end  
+
+      it "should return nil for a range with empty contents" do
+        @sheet1["another"].should == nil
+      end 
+
+      #it "should evaluate named formula" do
+      #  @sheet1["named_formula"].should == 4
+      #end                
+
+      #it "should evaluate a formula" do
+      #  @sheet1["another_formula"].should == 5
+      #end      
+
+      it "should raise an error if name not defined" do
+        expect {
+          @sheet1["foo"]
+        }.to raise_error(NameNotFound, /name "foo" not in #<Sheet: Sheet1/)        
+      end
+
+      it "should set a range to a value" do
+        @sheet1[1,1].Value.should == "foo"
+        @sheet1["firstcell"] = "bar"
+        @sheet1[1,1].Value.should == "bar"
+        @sheet1["new"] = "bar"
+        @sheet1["new"].should == "bar"
+      end
+
+      it "should raise an error if name cannot be evaluated" do
+        expect{
+          @sheet1["foo"] = 1
+          }.to raise_error(NameNotFound, /name "foo" not in #<Sheet: Sheet1/)
+      end
+    end
+
+    describe "nameval, set_nameval" do
+
+      before do
+        @book1 = Book.open(@dir + '/another_workbook.xls')
+        @sheet1 = @book1.sheet(1)
+      end
+
+      after do
+        @book1.close(:if_unsaved => :forget)
+      end   
+
+      it "should return value of a defined name" do
+        @sheet1.nameval("firstcell").should == "foo"
+      end
+
+      #it "should evaluate a formula" do
+      #  @sheet1.nameval("another_formula").should == 5
+      #end      
+
+      it "should raise an error if name not defined" do
+        expect {
+          @sheet1.nameval("foo")
+        }.to raise_error(NameNotFound, /name "foo" not in/)
+      end
+
+      it "should raise an error of coordinates are given instead of a defined name" do
+        expect {
+          @sheet1.nameval("A1")
+        }.to raise_error(NameNotFound, /name "A1" not in #<Sheet: Sheet1/)
+      end
+
+      it "should return default value for a range with empty contents" do
+        @sheet1.nameval("another", :default => 2) == 2
+      end 
+
+      it "should set a range to a value" do
+        @sheet1.nameval("firstcell").should == "foo"
+        @sheet1[1,1].Value.should == "foo"
+        @sheet1.set_nameval("firstcell","bar")
+        @sheet1.nameval("firstcell").should == "bar"
+        @sheet1[1,1].Value.should == "bar"
+      end
+
+      it "should raise an error if name cannot be evaluated" do
+        expect{
+          @sheet1.set_nameval("foo", 1)
+        }.to raise_error(NameNotFound, /name "foo" not in #<Sheet: Sheet1/)
+      end
+    end
+
+    describe "rangeval, set_rangeval" do
+      
+      before do
+        @book1 = Book.open(@dir + '/another_workbook.xls')
+        @sheet1 = @book1.sheet(1)
+        @sheet2 = @book1.sheet(2)
+      end
+
+      after do
+        @book1.close(:if_unsaved => :forget)
+      end   
+
+      it "should return value of a locally defined name" do
+        @sheet1.rangeval("firstcell").should == "foo"          
+      end        
+
+      it "should return value of a name with coordinates" do
+        @sheet1.rangeval("A1").should == "foo"         
+      end  
+
+      it "should return nil for a range with empty contents" do
+        @sheet1.rangeval("another").should == nil
+      end 
+
+      it "should return value of a defined name" do
+        @sheet1.rangeval("new").should == "foo"         
+        @sheet1.rangeval("one").should == 1.0    
+        @sheet1.rangeval("four").should == [[1,2],[3,4]]
+        @sheet1.rangeval("firstrow").should == [[1,2]]
+      end    
+
+      it "should return default value if name not defined and default value is given" do
+        @sheet1.rangeval("foo", :default => 2).should == 2
+      end
+
+      it "should raise an error if name not defined for the sheet" do
+        expect {
+          @sheet1.rangeval("foo")
+          }.to raise_error(NameNotFound, /name "foo" not in #<Sheet: Sheet1/)
+        expect {
+          @sheet1.rangeval("named_formula")
+          }.to raise_error(NameNotFound, /name "named_formula" not in #<Sheet: Sheet1/)
+        expect {
+          @sheet2.rangeval("firstcell")
+          }.to raise_error(NameNotFound, /name "firstcell" not in #<Sheet: Sheet2/)
+      end
+    
+      it "should set a range to a value" do
+        @sheet1.rangeval("firstcell").should == "foo"
+        @sheet1[1,1].Value.should == "foo"
+        @sheet1.set_rangeval("firstcell","bar")
+        @sheet1.rangeval("firstcell").should == "bar"
+        @sheet1[1,1].Value.should == "bar"          
+      end
+
+      it "should raise an error if name cannot be evaluated" do
+        expect{
+          @sheet1.set_nameval("foo", 1)
+        }.to raise_error(NameNotFound, /name "foo" not in #<Sheet: Sheet1/)
+      end
+
+      it "should raise an error if name not defined and default value is not provided" do
+        expect {
+          @sheet1.rangeval("foo", :default => nil)
+        }.to_not raise_error
+        expect {
+          @sheet1.rangeval("foo", :default => :__not_provided)
+        }.to raise_error(NameNotFound, /name "foo" not in #<Sheet: Sheet1 another_workbook/)
+        expect {
+          @sheet1.rangeval("foo")
+        }.to raise_error(NameNotFound, /name "foo" not in #<Sheet: Sheet1 another_workbook/)
+        @sheet1.rangeval("foo", :default => nil).should be_nil
+        @sheet1.rangeval("foo", :default => 1).should == 1
+        @sheet1.nameval("empty", :default => 1).should be_nil
+      end
+    end
+
+    describe "set_name" do
+
+      context "setting the name of a range" do
+
+         before do
+          @book1 = Book.open(@dir + '/another_workbook.xls', :read_only => true, :visible => true)
+          @book1.excel.displayalerts = false
+          @sheet1 = @book1.sheet(1)
+        end
+
+        after do
+          @book1.close
+        end   
+
+        it "should name an unnamed range with a giving address" do
+          expect{
+            @sheet1[1,2].Name.Name
+          }.to raise_error          
+          @sheet1.set_name("foo",1,2)
+          @sheet1[1,2].Name.Name.should == "Sheet1!foo"
+        end
+
+        it "should rename an already named range with a giving address" do
+          @sheet1[1,1].Name.Name.should == "Sheet1!firstcell"
+          @sheet1.set_name("foo",1,1)
+          @sheet1[1,1].Name.Name.should == "Sheet1!foo"
+        end
+
+        it "should raise an error" do
+          expect{
+            @sheet1.set_name("foo",-2,1)
+          }.to raise_error(RangeNotEvaluatable, /cannot add name "foo" to cell with row -2 and column 1/)
+        end
+      end
+    end
+
+    describe "send methods to worksheet" do
+
+      it "should send methods to worksheet" do
+        @sheet.Cells(1,1).Value.should eq 'foo'
+      end
+
+      it "should raise an error for unknown methods or properties" do
+        expect{
+          @sheet.Foo
+        }.to raise_error(VBAMethodMissingError, /unknown VBA property or method :Foo/)
+      end
+
+    end
+
+    describe "#method_missing" do
+      it "can access COM method" do
+        @sheet.Cells(1,1).Value.should eq 'foo'
+      end
+
+      context "unknown method" do
+        it { expect { @sheet.hogehogefoo }.to raise_error }
+      end
+    end
+
+  end
+end