gooddata_datawarehouse 0.0.9 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbb47425e959803a032aadd5eafa8b1b40c0ba1695648a49c8c3bed737be40b2
-  data.tar.gz: c81839b299f2c9cab6a5cced6fa403e7edd9f287fa05d02aa5d23c52139dd9ae
+  metadata.gz: f0d852dbd45a214766536c58b9ac732d6cb7574fc3e1c9a7bddbad590da2cdd9
+  data.tar.gz: b1b5f7e172325dd8b8c557637fecb49c08438da69a2cf6b077a8ce76d8d55131
 SHA512:
-  metadata.gz: 5225c46a79009619c6eaab6651d3d8f3d5f636572daa1db6ab9a27240a78e85bb77d7312957b89733da5df1a784c48fe7acb81f5ee5d2fdb1e625c43c4b3945d
-  data.tar.gz: 9eaf09fb89d312a544f33d357505ce95b44c3f5a1068ecce6a4dbbe80e06a99b2442050678976d866f6ea4023f452cd66d0fb19bc9cb725751ab55b47ec49f76
+  metadata.gz: 3e1928a456fd547a04ab20718e8f53cb3f28e933a617ce5e656ba31d703172352a0c1b3c4b20f2d3b2f4529bbd74fd1fa0656f44f7f005d1e0a41425dc822215
+  data.tar.gz: 9f6b2f9ee5fbf39033fe0aa7894d11a0f29b4f8b1c949280c80b84ed1caef5ac6a378c05f1556e1e0460668cc71206d0edfe6e643161336ac5de5aa1211799a0

data/.github/workflows/build.yml

@@ -0,0 +1,25 @@
+name: build
+on:
+  push:
+    branches: [master]
+jobs:
+  jruby-gem-release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-java@v2
+        with:
+          java-version: '11'
+          distribution: 'adopt' 
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 'jruby-9.4.0'
+          bundler-cache: true
+      - name: Run gem release
+        run: |
+          mkdir -p ~/.gem
+          echo -e "---\n:rubygems_api_key: ${{ secrets.RUBYGEMS_API_KEY }}" > ~/.gem/credentials
+          chmod 0600 ~/.gem/credentials
+          bundle exec rake gem:release

data/README.md

@@ -50,6 +50,12 @@ dwh = GoodData::Datawarehouse.new('you@gooddata.com', 'yourpass', 'your ADS inst
 # for custom jdbc url do:
 # dwh = GoodData::Datawarehouse.new('you@gooddata.com', 'yourpass', nil, :jdbc_url => 'jdbc:dss://whatever.com/something')
 
+# connect with SST (available from version 0.0.10)
+# dwh = GoodData::Datawarehouse.new_instance(:instance_id => 'your ADS instance id', :sst => 'SST token')
+# for custom jdbc url do:
+# dwh = GoodData::Datawarehouse.new_instance(:jdbc_url => 'jdbc:dss://whatever.com/something', :sst => 'SST token')
+ 
+
 # import a csv
 dwh.csv_to_new_table('my_table', 'path/to/my.csv')
 

data/Rakefile

@@ -1,8 +1,13 @@
-require 'coveralls/rake/task'
+require 'rubygems'
+
+require 'bundler/setup'
+require 'bundler/cli'
+require 'bundler/gem_tasks'
 require 'rake/testtask'
+require 'coveralls/rake/task'
 require 'rspec/core/rake_task'
 
-Coveralls::RakeTask.new
+RSpec::Core::RakeTask.new(:test)
 
 task default: %w[ci]
 
@@ -17,4 +22,20 @@ namespace :test do
   RSpec::Core::RakeTask.new(:unit) do |t|
     t.pattern = 'spec/**/*.rb'
   end
-end
+end
+
+namespace :gem do
+  desc "Release gem version #{GoodData::Datawarehouse} to rubygems"
+  task :release do
+    gem = "gooddata_datawarehouse-#{GoodData::Datawarehouse}.gem"
+    puts "Building #{gem} ..."
+    res = `gem build ./gooddata_datawarehouse.gemspec`
+    file = res.match('File: (.*)')[1]
+    next unless file
+
+    puts "Pushing #{file} ..."
+    system("gem push #{file}")
+  end
+end
+
+

data/gooddata_datawarehouse.gemspec

@@ -18,17 +18,21 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
+  spec.files.reject! { |fn| fn.start_with? 'spec/', 'data', 'Dockerfile' }
+  spec.files.reject! { |fn| fn.end_with? '.sh' }
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.3"
+  spec.add_development_dependency "bundler", "~> 2.3"
+  spec.add_development_dependency 'gooddata-crypto', '~> 0.1'
+  spec.add_development_dependency "rake", "~> 11.1"
   spec.add_development_dependency 'rspec', '~>3.8'
   spec.add_development_dependency 'pry', '~> 0.9'
   spec.add_development_dependency 'coveralls', '~> 0.7', '>= 0.7.0'
 
-  spec.add_dependency "sequel", "~> 4.17"
-  spec.add_dependency "gooddata-dss-jdbc", "~> 0.2.4"
+  spec.add_dependency "sequel", "~> 5.60"
+  spec.add_dependency "gooddata-dss-jdbc", "~> 0.2.7"
   spec.add_dependency "pmap", "~> 1.0"
+
 end

data/lib/gooddata_datawarehouse/datawarehouse.rb

@@ -10,14 +10,17 @@ require_relative 'sql_generator'
 module GoodData
   class Datawarehouse
     PARALEL_COPY_THREAD_COUNT = 10
+
+    def self.new_instance(opts={})
+      self.new(opts[:username], opts[:password], opts[:instance_id], opts)
+    end
+
     def initialize(username, password, instance_id, opts={})
       @logger = Logger.new(STDOUT)
       @username = username
       @password = password
+      @sst_token = opts[:sst]
       @jdbc_url = opts[:jdbc_url] || "jdbc:gdc:datawarehouse://secure.gooddata.com/gdc/datawarehouse/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."
@@ -192,11 +195,15 @@ module GoodData
     end
 
     def connect
-      Sequel.connect @jdbc_url,
-        :username => @username,
-        :password => @password do |connection|
-          yield(connection)
+      if @username.to_s.empty? || @password.to_s.empty?
+        @connection = Sequel.connect(@jdbc_url, :driver => Java.com.gooddata.dss.jdbc.driver.DssDriver, :jdbc_properties => {'sst' => @sst_token})
+      else
+        @connection = Sequel.connect(@jdbc_url, :username => @username, :password => @password)
       end
+      yield(@connection)
+    ensure
+      @connection.disconnect unless @connection.nil?
+      Sequel.synchronize{::Sequel::DATABASES.delete(@connection)}
     end
 
     private

data/lib/gooddata_datawarehouse/version.rb

@@ -1,5 +1,5 @@
 module GoodData
   class Datawarehouse
-    VERSION = "0.0.9"
+    VERSION = "0.0.11"
   end
 end

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: gooddata_datawarehouse
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.11
 platform: ruby
 authors:
 - Petr Cvengros
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-11-07 00:00:00.000000000 Z
+date: 2023-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.3'
   name: bundler
   prerelease: false
   type: :development
@@ -23,13 +23,27 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.3'
+        version: '0.1'
+  name: gooddata-crypto
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
   name: rake
   prerelease: false
   type: :development
@@ -37,7 +51,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.3'
+        version: '11.1'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -91,7 +105,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.17'
+        version: '5.60'
   name: sequel
   prerelease: false
   type: :runtime
@@ -99,13 +113,13 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.17'
+        version: '5.60'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.4
+        version: 0.2.7
   name: gooddata-dss-jdbc
   prerelease: false
   type: :runtime
@@ -113,7 +127,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.4
+        version: 0.2.7
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -136,6 +150,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".coveralls.yml"
+- ".github/workflows/build.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -143,19 +158,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- env_setup-example.sh
 - gooddata_datawarehouse.gemspec
 - lib/gooddata_datawarehouse.rb
 - lib/gooddata_datawarehouse/datawarehouse.rb
 - lib/gooddata_datawarehouse/sql_generator.rb
 - lib/gooddata_datawarehouse/version.rb
-- new-version.sh
-- spec/data/bike.csv
-- spec/data/bike2.csv
-- spec/data/emptyheader-bike.csv
-- spec/data/wrong-bike.csv
-- spec/datawarehouse_spec.rb
-- spec/spec_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -175,15 +182,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.6.13
+rubygems_version: 3.3.25
 signing_key:
 specification_version: 4
 summary: Convenient work with GoodData's Datawarehouse (ADS)
-test_files:
-- spec/data/bike.csv
-- spec/data/bike2.csv
-- spec/data/emptyheader-bike.csv
-- spec/data/wrong-bike.csv
-- spec/datawarehouse_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/env_setup-example.sh

@@ -1,5 +0,0 @@
-#!/bin/sh
-
-export USERNAME=""
-export PASSWORD=""
-export INSTANCE_ID=""

data/new-version.sh

@@ -1,23 +0,0 @@
-#!/bin/sh
-
-# get the new version
-VERSION=`bundle exec ruby <<-EORUBY
-
-  require 'gooddata_datawarehouse'
-  puts GoodData::Datawarehouse::VERSION
-
-EORUBY`
-
-# create tag and push it
-TAG="v$VERSION"
-git tag $TAG
-git push origin $TAG
-
-# build and push the gem
-gem build gooddata_datawarehouse.gemspec
-gem push "gooddata_datawarehouse-$VERSION.gem"
-
-# update the gem after a few secs
-echo "Sleeping.."
-sleep 30
-gem update gooddata_datawarehouse

data/spec/data/bike.csv

@@ -1,5 +0,0 @@
-wheel_size,manufacturer
-"29","Specialized"
-"27.5","Scott"
-"29","Scott"
-"989","989"

data/spec/data/bike2.csv

@@ -1,4 +0,0 @@
-wheel_size,manufacturer
-"29","Ibis"
-"27.5","Seven"
-"29","Moots"

data/spec/data/emptyheader-bike.csv

@@ -1,4 +0,0 @@
-"","manufacturer",""
-"29","Ibis","1"
-"27.5","Seven","2"
-"29","Moots","3"

data/spec/data/wrong-bike.csv

@@ -1,6 +0,0 @@
-wheel_size,manufacturer
-"29","Specialized"
-"27.5","Scott"
-"29","Scott"
-"989","989"
-"26","Something","Too much cols"

data/spec/datawarehouse_spec.rb

@@ -1,406 +0,0 @@
-require 'tempfile'
-require 'gooddata_datawarehouse/datawarehouse'
-
-CSV_PATH = 'spec/data/bike.csv'
-CSV_PATH2 = 'spec/data/bike2.csv'
-WRONG_CSV_PATH = 'spec/data/wrong-bike.csv'
-EMPTY_HEADER_CSV_PATH = 'spec/data/emptyheader-bike.csv'
-CSV_REGEXP = 'spec/data/bike*.csv'
-
-class Helper
-  def self.create_default_connection
-    GoodData::Datawarehouse.new(ENV['USERNAME'], ENV['PASSWORD'], ENV['INSTANCE_ID'])
-  end
-  def self.line_count(f)
-    i = 0
-    CSV.foreach(f, :headers => true) {|_| i += 1}
-    i
-  end
-end
-
-describe GoodData::Datawarehouse do
-  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
-
-    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
-
-        # 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)
-
-        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)
-
-        # 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
-
-    describe '#drop_table' do
-      it 'drops a table' do
-        cols = ['col1', 'col2', 'col3']
-
-        @dwh.create_table(@random_table_name, cols)
-        expect(@dwh.table_exists?(@random_table_name)).to eq true
-
-        # 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
-
-    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
-
-    def check_table_exists
-      # table exists
-      expect(@dwh.table_exists?(@random_table_name)).to eq true
-    end
-
-    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
-
-    describe '#rename_table' do
-      it 'renames a table' do
-        cols = ['col1', 'col2', 'col3']
-
-        @dwh.create_table(@random_table_name, cols)
-        expect(@dwh.table_exists?(@random_table_name)).to eq true
-
-        # 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
-
-        @created_tables = [changed_name]
-      end
-    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
-
-        # cols are the same as in the csv
-        check_cols
-      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)
-
-          @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 given in a list" do
-        @dwh.csv_to_new_table(@random_table_name, [CSV_PATH, CSV_PATH2])
-
-        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)
-
-        check_table_exists
-        check_cols
-        check_row_count
-      end
-
-      it 'writes exceptions and rejections to files at given path, passed strings' do
-        rej = Tempfile.new('rejections.csv')
-        exc = Tempfile.new('exceptions.csv')
-
-        @dwh.csv_to_new_table(@random_table_name, CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path)
-
-        expect(File.size(rej)).to eq 0
-        expect(File.size(exc)).to eq 0
-      end
-
-      it 'overwrites the rejections and exceptions' do
-        rej = Tempfile.new('rejections.csv')
-        exc = Tempfile.new('exceptions.csv')
-
-        @dwh.csv_to_new_table(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
-
-        rej_size = File.size(rej)
-        exc_size = File.size(exc)
-
-        expect(rej_size).to be > 0
-        expect(exc_size).to be > 0
-
-        # 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(File.size(rej)).to eq rej_size
-        expect(File.size(exc)).to be exc_size
-      end
-
-      it 'writes exceptions and rejections to files at given path, passed files' do
-        rej = Tempfile.new('rejections.csv')
-        exc = Tempfile.new('exceptions.csv')
-
-        @dwh.csv_to_new_table(@random_table_name, CSV_PATH, :exceptions_file => exc, :rejections_file => rej)
-
-        expect(File.size(rej)).to eq 0
-        expect(File.size(exc)).to eq 0
-      end
-
-      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')
-
-        @dwh.csv_to_new_table(@random_table_name, WRONG_CSV_PATH, :exceptions_file => exc.path, :rejections_file => rej.path, :ignore_parse_errors => true)
-
-        expect(File.size(rej)).to be > 0
-        expect(File.size(exc)).to be > 0
-      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')
-
-        if File.dirname(rej) != File.dirname(exc)
-          raise "two directories for tempfiles!"
-        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)
-        end
-
-
-        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
-
-        # 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)
-
-        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
-
-        @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
-
-      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')
-
-        @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')
-      end
-    end
-
-    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
-
-        # 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))
-
-        expect(exported).to eq imported
-      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
-
-        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)
-
-        # 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))
-
-        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
-
-        # load the data there
-        @dwh.load_data_from_csv(@random_table_name, [CSV_PATH, CSV_PATH2])
-
-        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
-
-        # 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
-
-        # 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
-
-      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])
-
-        # append the data
-        @dwh.load_data_from_csv(@random_table_name, CSV_PATH2, :append => true)
-        check_row_count([CSV_PATH, CSV_PATH2])
-      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
-      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)
-      end
-      # TODO more tests
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,8 +0,0 @@
-require 'coveralls'
-Coveralls.wear!
-
-RSpec.configure do |c|
-  c.filter_run :focus => true
-  c.run_all_when_everything_filtered = true
-end
-