gooddata_datawarehouse 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 453c08405c8e4e9c2fc46b6b2fb1f1df22f2f4ae
-  data.tar.gz: ce89580d666c0d660a61a72def8f6d7d28d4ab9d
+  metadata.gz: 4df42b6be9975a0f86aa383914db372e5ca91361
+  data.tar.gz: e13dd331a4a0c9dd0e817def626b70fa0959d4d5
 SHA512:
-  metadata.gz: 5d40a9ece4f77255e2d2f750d0082bc5ca0d19bb1d99ae013d8da5331000b1c86022e3dc4c8b70b54cda7da130332a6b3b19ac4eeb280d27573d19bd8cafc1ed
-  data.tar.gz: 69fc15c0a428e8e32db4b20f07b7fa7ef686342df98e210dc1a4540e6af85569f31cebb00a867d9fe5e15a62f3326c1d3c74db0b4a31fb6d7b4c777fc6755c4a
+  metadata.gz: e1bc334616cb41069cbc6cbd9aac87dd7ec48e55b3c9ae25e38cd9941ef60924d523bee6b816cecd78fde0951295571659821fe627f9a4ace273264b275c88f4
+  data.tar.gz: f8dffb2a551d20e4a577de3fa7780b1f69898a33889b3128e54623b16a9aabed5964ab04a76c3ab9a264933e6984f837b22a2b205af78faf8ac967197419d22a

data/README.md

@@ -47,6 +47,8 @@ dwh = GoodData::Datawarehouse.new('you@gooddata.com', 'yourpass', 'your ADS inst
 # instance id is the identifier of your datawarehouse (ADS). 
 # E.g. for datawarehouse https://secure.gooddata.com/gdc/datawarehouse/instances/d4979ac54df8afb7b5192b0086de6270
 # the instance id is d4979ac54df8afb7b5192b0086de6270
+# for custom jdbc url do:
+# dwh = GoodData::Datawarehouse.new('you@gooddata.com', 'yourpass', nil, 'jdbc:dss://whatever.com/something')
 
 # import a csv
 dwh.csv_to_new_table('my_table', 'path/to/my.csv')

data/lib/gooddata_datawarehouse/datawarehouse.rb

@@ -14,9 +14,13 @@ module GoodData
       @logger = Logger.new(STDOUT)
       @username = username
       @password = password
-      @jdbc_url = "jdbc:dss://secure.gooddata.com/gdc/dss/instances/#{instance_id}"
-      if @username.nil? || @password.nil? || instance_id.nil?
-        fail ArgumentError, "username, password and/or instance_id are nil. All of them are mandatory."
+      @jdbc_url = opts[:jdbc_url] || "jdbc:dss://secure.gooddata.com/gdc/dss/instances/#{instance_id}"
+      if @username.nil? || @password.nil?
+        fail ArgumentError, "username and/or password are nil. All of them are mandatory."
+      end
+
+      if instance_id.nil? && opts[:jdbc_url].nil?
+        fail ArgumentError, "you must either provide instance_id or jdbc_url option."
       end
 
       Jdbc::DSS.load_driver

data/lib/gooddata_datawarehouse/version.rb

@@ -1,5 +1,5 @@
 module GoodData
   class Datawarehouse
-    VERSION = "0.0.7"
+    VERSION = "0.0.8"
   end
 end

data/spec/datawarehouse_spec.rb

@@ -19,380 +19,388 @@ class Helper
 end
 
 describe GoodData::Datawarehouse do
-  before(:each) do
-    @dwh = Helper::create_default_connection
-    @random = rand(10000000).to_s
-    @random_table_name = "temp_#{@random}"
-    @created_tables = nil
+  describe "dwh instance creation" do
+    it "creates an instance with custom jdbc url" do
+      dwh = GoodData::Datawarehouse.new(ENV['USERNAME'], ENV['PASSWORD'], nil, :jdbc_url => "jdbc:dss://secure.gooddata.com/gdc/dss/instances/#{ENV['INSTANCE_ID']}")
+      expect(dwh.table_exists?('hahahaha')).to eq false
+    end
   end
+  describe 'Table operations' do
+    before(:each) do
+      @dwh = Helper::create_default_connection
+      @random = rand(10000000).to_s
+      @random_table_name = "temp_#{@random}"
+      @created_tables = nil
+    end
 
-  after(:each) do
-    @created_tables ||= [@random_table_name]
-    @created_tables.each{|t| @dwh.drop_table(t) if t} if @created_tables
-  end
+    after(:each) do
+      @created_tables ||= [@random_table_name]
+      @created_tables.each{|t| @dwh.drop_table(t) if t} if @created_tables
+    end
 
-  describe '#create_table' do
-    it 'creates a table with default type' do
-      cols = ['col1', 'col2', 'col3']
-      @dwh.create_table(@random_table_name, cols)
+    describe '#create_table' do
+      it 'creates a table with default type' do
+        cols = ['col1', 'col2', 'col3']
+        @dwh.create_table(@random_table_name, cols)
 
-      # table exists
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
+        # table exists
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
 
-      # cols are the same
-      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
-    end
+        # cols are the same
+        expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+      end
 
-    it "doesn't create a table when it already exists" do
-      cols = ['col1', 'col2', 'col3']
-      cols2 = ['col1', 'col2']
-      @dwh.create_table(@random_table_name, cols)
+      it "doesn't create a table when it already exists" do
+        cols = ['col1', 'col2', 'col3']
+        cols2 = ['col1', 'col2']
+        @dwh.create_table(@random_table_name, cols)
 
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
 
-      # try to create a table with di
-      @dwh.create_table(@random_table_name, cols2, skip_if_exists: true)
+        # try to create a table with di
+        @dwh.create_table(@random_table_name, cols2, skip_if_exists: true)
 
-      # table still exists
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
-      # cols are the same
-      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+        # table still exists
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
+        # cols are the same
+        expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+      end
+
+      it 'creates a table with given types' do
+        cols = [
+          {
+            column_name: 'col1',
+            data_type: 'varchar(88)'
+          }, {
+            column_name: 'col2',
+            data_type: 'int'
+          }, {
+            column_name: 'col3',
+            data_type: 'boolean'
+          }
+        ]
+        @dwh.create_table(@random_table_name, cols)
+
+        # table exists
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+        # cols are the same
+        expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(cols)
+      end
     end
 
-    it 'creates a table with given types' do
-      cols = [
-        {
-          column_name: 'col1',
-          data_type: 'varchar(88)'
-        }, {
-          column_name: 'col2',
-          data_type: 'int'
-        }, {
-          column_name: 'col3',
-          data_type: 'boolean'
-        }
-      ]
-      @dwh.create_table(@random_table_name, cols)
+    describe '#drop_table' do
+      it 'drops a table' do
+        cols = ['col1', 'col2', 'col3']
 
-      # table exists
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
+        @dwh.create_table(@random_table_name, cols)
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
 
-      # cols are the same
-      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(cols)
+        # it shouldn't exist after being dropped
+        @dwh.drop_table(@random_table_name)
+        expect(@dwh.table_exists?(@random_table_name)).to eq false
+
+        @random_table_name = nil
+      end
     end
-  end
 
-  describe '#drop_table' do
-    it 'drops a table' do
-      cols = ['col1', 'col2', 'col3']
+    def check_cols
+      # cols are the same as in the csv
+      expected_cols = File.open(CSV_PATH, &:gets).strip.split(',')
+      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(expected_cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+    end
 
-      @dwh.create_table(@random_table_name, cols)
+    def check_table_exists
+      # table exists
       expect(@dwh.table_exists?(@random_table_name)).to eq true
+    end
 
-      # it shouldn't exist after being dropped
-      @dwh.drop_table(@random_table_name)
-      expect(@dwh.table_exists?(@random_table_name)).to eq false
-
-      @random_table_name = nil
+    def check_row_count(files=[CSV_PATH, CSV_PATH2])
+      expected_count = files.map {|f| Helper.line_count(f)}.reduce(:+)
+      # there are lines from both of the csvs
+      expect(@dwh.table_row_count(@random_table_name)).to eq expected_count
     end
-  end
 
-  def check_cols
-    # cols are the same as in the csv
-    expected_cols = File.open(CSV_PATH, &:gets).strip.split(',')
-    expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(expected_cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
-  end
+    describe '#rename_table' do
+      it 'renames a table' do
+        cols = ['col1', 'col2', 'col3']
 
-  def check_table_exists
-    # table exists
-    expect(@dwh.table_exists?(@random_table_name)).to eq true
-  end
+        @dwh.create_table(@random_table_name, cols)
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
 
-  def check_row_count(files=[CSV_PATH, CSV_PATH2])
-    expected_count = files.map {|f| Helper.line_count(f)}.reduce(:+)
-    # there are lines from both of the csvs
-    expect(@dwh.table_row_count(@random_table_name)).to eq expected_count
-  end
+        # the renamed table should exist, not the old name
+        changed_name = "#{@random_table_name}_something"
+        @dwh.rename_table(@random_table_name, changed_name)
+        expect(@dwh.table_exists?(@random_table_name)).to eq false
+        expect(@dwh.table_exists?(changed_name)).to eq true
 
-  describe '#rename_table' do
-    it 'renames a table' do
-      cols = ['col1', 'col2', 'col3']
+        @created_tables = [changed_name]
+      end
+    end
 
-      @dwh.create_table(@random_table_name, cols)
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
+    describe '#csv_to_new_table' do
+      it 'creates a new table from csv' do
+        @dwh.csv_to_new_table(@random_table_name, CSV_PATH)
 
-      # the renamed table should exist, not the old name
-      changed_name = "#{@random_table_name}_something"
-      @dwh.rename_table(@random_table_name, changed_name)
-      expect(@dwh.table_exists?(@random_table_name)).to eq false
-      expect(@dwh.table_exists?(changed_name)).to eq true
+        # table exists
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
 
-      @created_tables = [changed_name]
-    end
-  end
+        # cols are the same as in the csv
+        check_cols
+      end
 
-  describe '#csv_to_new_table' do
-    it 'creates a new table from csv' do
-      @dwh.csv_to_new_table(@random_table_name, CSV_PATH)
 
-      # table exists
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
+      it "loads all files in a directory, in paralel" do
+        # make a tempdir and copy the csvs there
+        Dir.mktmpdir('foo') do |dir|
+          FileUtils.cp(CSV_PATH, dir)
+          FileUtils.cp(CSV_PATH2, dir)
 
-      # cols are the same as in the csv
-      check_cols
-    end
+          @dwh.csv_to_new_table(@random_table_name, dir, :paralel_copy_thread_count => 2)
+        end
 
+        check_table_exists
+        check_cols
+        check_row_count
+      end
 
-    it "loads all files in a directory, in paralel" do
-      # make a tempdir and copy the csvs there
-      Dir.mktmpdir('foo') do |dir|
-        FileUtils.cp(CSV_PATH, dir)
-        FileUtils.cp(CSV_PATH2, dir)
+      it "loads all files given in a list" do
+        @dwh.csv_to_new_table(@random_table_name, [CSV_PATH, CSV_PATH2])
 
-        @dwh.csv_to_new_table(@random_table_name, dir, :paralel_copy_thread_count => 2)
+        check_table_exists
+        check_cols
+        check_row_count
       end
 
-      check_table_exists
-      check_cols
-      check_row_count
-    end
-
-    it "loads all files given in a list" do
-      @dwh.csv_to_new_table(@random_table_name, [CSV_PATH, CSV_PATH2])
+      it "loads all files given by a regexp" do
+        @dwh.csv_to_new_table(@random_table_name, CSV_REGEXP)
 
-      check_table_exists
-      check_cols
-      check_row_count
-    end
+        check_table_exists
+        check_cols
+        check_row_count
+      end
 
-    it "loads all files given by a regexp" do
-      @dwh.csv_to_new_table(@random_table_name, CSV_REGEXP)
+      it 'writes exceptions and rejections to files at given path, passed strings' do
+        rej = Tempfile.new('rejections.csv')
+        exc = Tempfile.new('exceptions.csv')
 
-      check_table_exists
-      check_cols
-      check_row_count
-    end
+        @dwh.csv_to_new_table(@random_table_name, CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path)
 
-    it 'writes exceptions and rejections to files at given path, passed strings' do
-      rej = Tempfile.new('rejections.csv')
-      exc = Tempfile.new('exceptions.csv')
+        expect(File.size(rej)).to eq 0
+        expect(File.size(exc)).to eq 0
+      end
 
-      @dwh.csv_to_new_table(@random_table_name, CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path)
+      it 'overwrites the rejections and exceptions' do
+        rej = Tempfile.new('rejections.csv')
+        exc = Tempfile.new('exceptions.csv')
 
-      expect(File.size(rej)).to eq 0
-      expect(File.size(exc)).to eq 0
-    end
+        @dwh.csv_to_new_table(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
 
-    it 'overwrites the rejections and exceptions' do
-      rej = Tempfile.new('rejections.csv')
-      exc = Tempfile.new('exceptions.csv')
+        rej_size = File.size(rej)
+        exc_size = File.size(exc)
 
-      @dwh.csv_to_new_table(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
+        expect(rej_size).to be > 0
+        expect(exc_size).to be > 0
 
-      rej_size = File.size(rej)
-      exc_size = File.size(exc)
+        # load it again and see if it was overwritten - has the same size
+        @dwh.load_data_from_csv(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
 
-      expect(rej_size).to be > 0
-      expect(exc_size).to be > 0
+        expect(File.size(rej)).to eq rej_size
+        expect(File.size(exc)).to be exc_size
+      end
 
-      # load it again and see if it was overwritten - has the same size
-      @dwh.load_data_from_csv(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
+      it 'writes exceptions and rejections to files at given path, passed files' do
+        rej = Tempfile.new('rejections.csv')
+        exc = Tempfile.new('exceptions.csv')
 
-      expect(File.size(rej)).to eq rej_size
-      expect(File.size(exc)).to be exc_size
-    end
+        @dwh.csv_to_new_table(@random_table_name, CSV_PATH, :exceptions_file => exc, :rejections_file => rej)
 
-    it 'writes exceptions and rejections to files at given path, passed files' do
-      rej = Tempfile.new('rejections.csv')
-      exc = Tempfile.new('exceptions.csv')
+        expect(File.size(rej)).to eq 0
+        expect(File.size(exc)).to eq 0
+      end
 
-      @dwh.csv_to_new_table(@random_table_name, CSV_PATH, :exceptions_file => exc, :rejections_file => rej)
+      it "writes exceptions and rejections to files at given absolute path, when it's wrong there's something" do
+        rej = Tempfile.new('rejections.csv')
+        exc = Tempfile.new('exceptions.csv')
 
-      expect(File.size(rej)).to eq 0
-      expect(File.size(exc)).to eq 0
-    end
+        @dwh.csv_to_new_table(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
 
-    it "writes exceptions and rejections to files at given absolute path, when it's wrong there's something" do
-      rej = Tempfile.new('rejections.csv')
-      exc = Tempfile.new('exceptions.csv')
+        expect(File.size(rej)).to be > 0
+        expect(File.size(exc)).to be > 0
+      end
 
-      @dwh.csv_to_new_table(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
+      it "writes exceptions and rejections to files at given relative path, when it's wrong there's something" do
+        rej = Tempfile.new('rejections.csv')
+        exc = Tempfile.new('exceptions.csv')
 
-      expect(File.size(rej)).to be > 0
-      expect(File.size(exc)).to be > 0
-    end
+        if File.dirname(rej) != File.dirname(exc)
+          raise "two directories for tempfiles!"
+        end
 
-    it "writes exceptions and rejections to files at given relative path, when it's wrong there's something" do
-      rej = Tempfile.new('rejections.csv')
-      exc = Tempfile.new('exceptions.csv')
+        csv_path = File.expand_path(WRONG_CSV_PATH)
 
-      if File.dirname(rej) != File.dirname(exc)
-        raise "two directories for tempfiles!"
-      end
+        Dir.chdir(File.dirname(rej)) do
+          @dwh.csv_to_new_table(@random_table_name, csv_path, :exceptions_file => File.basename(exc), :rejections_file => File.basename(rej), :ignore_parse_errors => true)
+        end
 
-      csv_path = File.expand_path(WRONG_CSV_PATH)
 
-      Dir.chdir(File.dirname(rej)) do
-        @dwh.csv_to_new_table(@random_table_name, csv_path, :exceptions_file => File.basename(exc), :rejections_file => File.basename(rej), :ignore_parse_errors => true)
+        expect(File.size(rej)).to be > 0
+        expect(File.size(exc)).to be > 0
       end
 
+      it "loads fine when ignoring errors and not passing files" do
+        @dwh.csv_to_new_table(@random_table_name, CSV_PATH, :ignore_parse_errors => true)
 
-      expect(File.size(rej)).to be > 0
-      expect(File.size(exc)).to be > 0
-    end
-
-    it "loads fine when ignoring errors and not passing files" do
-      @dwh.csv_to_new_table(@random_table_name, CSV_PATH, :ignore_parse_errors => true)
-
-      # table exists
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
+        # table exists
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
 
-      # cols are the same as in the csv
-      expected_cols = File.open(CSV_PATH, &:gets).strip.split(',')
-      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(expected_cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
-    end
+        # cols are the same as in the csv
+        expected_cols = File.open(CSV_PATH, &:gets).strip.split(',')
+        expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(expected_cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+      end
 
-    it "works with non-existing rejection/exception files" do
-      t = Tempfile.new('haha')
-      d = File.dirname(t)
+      it "works with non-existing rejection/exception files" do
+        t = Tempfile.new('haha')
+        d = File.dirname(t)
 
-      rej = File.join(d, @random_table_name + '_rej')
-      exc = File.join(d, @random_table_name + '_exc')
+        rej = File.join(d, @random_table_name + '_rej')
+        exc = File.join(d, @random_table_name + '_exc')
 
-      expect(File.exists?(rej)).to be false
-      expect(File.exists?(exc)).to be false
+        expect(File.exists?(rej)).to be false
+        expect(File.exists?(exc)).to be false
 
-      @dwh.csv_to_new_table(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc, :rejections_file => rej, :ignore_parse_errors => true)
+        @dwh.csv_to_new_table(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc, :rejections_file => rej, :ignore_parse_errors => true)
 
-      expect(File.size(rej)).to be > 0
-      expect(File.size(exc)).to be > 0
-    end
+        expect(File.size(rej)).to be > 0
+        expect(File.size(exc)).to be > 0
+      end
 
-    it "fails if one of the files is wrong" do
-      expect{@dwh.csv_to_new_table(@random_table_name, [CSV_PATH, WRONG_CSV_PATH])}.to raise_error(ArgumentError)
-    end
+      it "fails if one of the files is wrong" do
+        expect{@dwh.csv_to_new_table(@random_table_name, [CSV_PATH, WRONG_CSV_PATH])}.to raise_error(ArgumentError)
+      end
 
-    it "creates exceptions / rejections for each file when wanted" do
-      rej = Tempfile.new('rejections.csv')
-      exc = Tempfile.new('exceptions.csv')
+      it "creates exceptions / rejections for each file when wanted" do
+        rej = Tempfile.new('rejections.csv')
+        exc = Tempfile.new('exceptions.csv')
 
-      @dwh.csv_to_new_table(@random_table_name, [CSV_PATH, WRONG_CSV_PATH], :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
+        @dwh.csv_to_new_table(@random_table_name, [CSV_PATH, WRONG_CSV_PATH], :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
 
-      expect(File.size("#{rej.path}-#{File.basename(WRONG_CSV_PATH)}")).to be > 0
-      expect(File.size("#{exc.path}-#{File.basename(WRONG_CSV_PATH)}")).to be > 0
-    end
-    it "creates empty1, etc. columns for empty header columns" do
-      @dwh.csv_to_new_table(@random_table_name, EMPTY_HEADER_CSV_PATH)
-      # it should have cols empty1,2
-      expect(@dwh.get_columns(@random_table_name).map {|c| c[:column_name]}).to include('empty1', 'empty2')
+        expect(File.size("#{rej.path}-#{File.basename(WRONG_CSV_PATH)}")).to be > 0
+        expect(File.size("#{exc.path}-#{File.basename(WRONG_CSV_PATH)}")).to be > 0
+      end
+      it "creates empty1, etc. columns for empty header columns" do
+        @dwh.csv_to_new_table(@random_table_name, EMPTY_HEADER_CSV_PATH)
+        # it should have cols empty1,2
+        expect(@dwh.get_columns(@random_table_name).map {|c| c[:column_name]}).to include('empty1', 'empty2')
+      end
     end
-  end
 
-  describe '#export_table' do
-    it 'exports a created table' do
-      @dwh.csv_to_new_table(@random_table_name, CSV_PATH)
+    describe '#export_table' do
+      it 'exports a created table' do
+        @dwh.csv_to_new_table(@random_table_name, CSV_PATH)
 
-      # table exists
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
+        # table exists
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
 
-      # export it
-      f = Tempfile.new('bike.csv')
-      @dwh.export_table(@random_table_name, f)
+        # export it
+        f = Tempfile.new('bike.csv')
+        @dwh.export_table(@random_table_name, f)
 
-      # should be the same except for order of the lines
-      imported = Set.new(CSV.read(CSV_PATH))
-      exported = Set.new(CSV.read(f))
+        # should be the same except for order of the lines
+        imported = Set.new(CSV.read(CSV_PATH))
+        exported = Set.new(CSV.read(f))
 
-      expect(exported).to eq imported
+        expect(exported).to eq imported
+      end
     end
-  end
 
-  describe '#load_data_from_csv' do
-    it 'loads data from csv to existing table' do
-      # create the table
-      @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
+    describe '#load_data_from_csv' do
+      it 'loads data from csv to existing table' do
+        # create the table
+        @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
 
-      expected_cols = File.open(CSV_PATH, &:gets).strip.split(',')
-      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(expected_cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+        expected_cols = File.open(CSV_PATH, &:gets).strip.split(',')
+        expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(expected_cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
 
-      # load the data there
-      @dwh.load_data_from_csv(@random_table_name, CSV_PATH)
+        # load the data there
+        @dwh.load_data_from_csv(@random_table_name, CSV_PATH)
 
-      # export it
-      f = Tempfile.new('bike.csv')
-      @dwh.export_table(@random_table_name, f)
+        # export it
+        f = Tempfile.new('bike.csv')
+        @dwh.export_table(@random_table_name, f)
 
-      # should be the same except for order of the lines
-      imported = Set.new(CSV.read(CSV_PATH))
-      exported = Set.new(CSV.read(f))
+        # should be the same except for order of the lines
+        imported = Set.new(CSV.read(CSV_PATH))
+        exported = Set.new(CSV.read(f))
 
-      expect(exported).to eq imported
-    end
+        expect(exported).to eq imported
+      end
 
-    it "can load multiple files" do
-      # create the table
-      @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
-      check_table_exists
-      check_cols
+      it "can load multiple files" do
+        # create the table
+        @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
+        check_table_exists
+        check_cols
 
-      # load the data there
-      @dwh.load_data_from_csv(@random_table_name, [CSV_PATH, CSV_PATH2])
+        # load the data there
+        @dwh.load_data_from_csv(@random_table_name, [CSV_PATH, CSV_PATH2])
 
-      check_row_count
-    end
+        check_row_count
+      end
 
-    it 'fails for a wrong csv' do
-      # create the table
-      @dwh.create_table_from_csv_header(@random_table_name, WRONG_CSV_PATH)
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
+      it 'fails for a wrong csv' do
+        # create the table
+        @dwh.create_table_from_csv_header(@random_table_name, WRONG_CSV_PATH)
+        expect(@dwh.table_exists?(@random_table_name)).to eq true
 
-      # load the data there - expect fail
-      expect{@dwh.load_data_from_csv(@random_table_name, WRONG_CSV_PATH)}.to raise_error(ArgumentError)
-    end
+        # load the data there - expect fail
+        expect{@dwh.load_data_from_csv(@random_table_name, WRONG_CSV_PATH)}.to raise_error(ArgumentError)
+      end
 
-    it 'truncates the data that is already there' do
-      @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
-      check_table_exists
-      check_cols
+      it 'truncates the data that is already there' do
+        @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
+        check_table_exists
+        check_cols
 
-      # load the data there
-      @dwh.load_data_from_csv(@random_table_name, CSV_PATH)
-      check_row_count([CSV_PATH])
+        # load the data there
+        @dwh.load_data_from_csv(@random_table_name, CSV_PATH)
+        check_row_count([CSV_PATH])
 
-      # load the data there again, count should stay
-      @dwh.load_data_from_csv(@random_table_name, CSV_PATH2)
-      check_row_count([CSV_PATH2])
-    end
+        # load the data there again, count should stay
+        @dwh.load_data_from_csv(@random_table_name, CSV_PATH2)
+        check_row_count([CSV_PATH2])
+      end
 
-    it "keeps the data that is there if append option passed" do
-      @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
-      check_table_exists
-      check_cols
+      it "keeps the data that is there if append option passed" do
+        @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
+        check_table_exists
+        check_cols
 
-      # load the data there
-      @dwh.load_data_from_csv(@random_table_name, CSV_PATH)
-      check_row_count([CSV_PATH])
+        # load the data there
+        @dwh.load_data_from_csv(@random_table_name, CSV_PATH)
+        check_row_count([CSV_PATH])
 
-      # append the data
-      @dwh.load_data_from_csv(@random_table_name, CSV_PATH2, :append => true)
-      check_row_count([CSV_PATH, CSV_PATH2])
+        # append the data
+        @dwh.load_data_from_csv(@random_table_name, CSV_PATH2, :append => true)
+        check_row_count([CSV_PATH, CSV_PATH2])
+      end
     end
-  end
 
-  describe "#truncate_table" do
-    it "truncates the given table" do
-      @dwh.csv_to_new_table(@random_table_name, CSV_PATH)
-      @dwh.truncate_table(@random_table_name)
-      expect(@dwh.table_row_count(@random_table_name)).to eq 0
+    describe "#truncate_table" do
+      it "truncates the given table" do
+        @dwh.csv_to_new_table(@random_table_name, CSV_PATH)
+        @dwh.truncate_table(@random_table_name)
+        expect(@dwh.table_row_count(@random_table_name)).to eq 0
+      end
     end
-  end
 
-  describe '#get_columns' do
-    it 'gives you the right list of columns' do
-      expected_cols = File.open(CSV_PATH, &:gets).strip.split(',')
-      @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
+    describe '#get_columns' do
+      it 'gives you the right list of columns' do
+        expected_cols = File.open(CSV_PATH, &:gets).strip.split(',')
+        @dwh.create_table_from_csv_header(@random_table_name, CSV_PATH)
+      end
+      # TODO more tests
     end
-    # TODO more tests
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gooddata_datawarehouse
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Petr Cvengros
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-09 00:00:00.000000000 Z
+date: 2015-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement