bigbroda 0.0.7 → 0.1.0.pre

data/lib/{google_bigquery → bigbroda}/dataset.rb

@@ -1,50 +1,50 @@
 
-module GoogleBigquery
-  class Dataset < GoogleBigquery::Client
+module BigBroda
+  class Dataset < BigBroda::Client
 
-    attr_accessor :options 
+    attr_accessor :options
 
     def initialize( opts={})
       super
     end
 
     def self.list(project_id)
-      parse_response GoogleBigquery::Auth.client.execute( 
-        GoogleBigquery::Auth.api.datasets.list,
+      parse_response BigBroda::Auth.client.execute(
+        BigBroda::Auth.api.datasets.list,
         projectId: project_id
       )
     end
 
     def self.get(project_id, dataset_id)
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.datasets.get, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.datasets.get,
         :parameters=> {"projectId"=> project_id, "datasetId"=> dataset_id }
       )
       parse_response(res)
     end
 
     def self.update(project_id, dataset_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.datasets.update, 
-        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}}, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.datasets.update,
+        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}},
         :parameters=> {"projectId"=> project_id, "datasetId"=> dataset_id }
       )
       parse_response(res)
     end
 
     def self.patch(project_id, dataset_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.datasets.update, 
-        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}}, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.datasets.update,
+        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}},
         :parameters=> {"projectId"=> project_id, "datasetId"=> dataset_id }
       )
       parse_response(res)
     end
 
     def self.create(project_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.datasets.insert, 
-        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}}, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.datasets.insert,
+        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}},
         :parameters=> {"projectId"=> project_id }
       )
       parse_response(res)
@@ -55,18 +55,18 @@ module GoogleBigquery
 
     def self.delete(project_id, dataset_id, body={})
 
-      tables = GoogleBigquery::Table.list(project_id, dataset_id)["tables"]
-      
+      tables = BigBroda::Table.list(project_id, dataset_id)["tables"]
+
       unless tables.nil? or tables.empty?
-        tables.map!{|o| o["tableReference"]["tableId"]} 
+        tables.map!{|o| o["tableReference"]["tableId"]}
         tables.each do |table_id|
-          GoogleBigquery::Table.delete(project_id, dataset_id, table_id)
+          BigBroda::Table.delete(project_id, dataset_id, table_id)
         end
       end
 
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.datasets.delete, 
-        #:body_object=> {"deleteContents"=> true}, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.datasets.delete,
+        #:body_object=> {"deleteContents"=> true},
         :parameters=> {"projectId"=> project_id, "datasetId" => dataset_id }
       )
       res.status == 204 ?  true : parse_response(res)

data/lib/{google_bigquery → bigbroda}/engine.rb

@@ -2,10 +2,10 @@
 
 require "active_record/connection_adapters/bigquery_adapter.rb"
 
-module GoogleBigquery
+module BigBroda
   class Engine < ::Rails::Engine
-    
-    isolate_namespace GoogleBigquery
+
+    isolate_namespace BigBroda
     #config.generators do |g|
     #  g.test_framework  :rspec,
     #                    :fixture_replacement => :factory_girl ,
@@ -13,7 +13,7 @@ module GoogleBigquery
     #  g.integration_tool :rspec
     #end
 
-    #initializer "require GoogleBigquery" do 
+    #initializer "require BigBroda" do
     #end
 
   end

data/lib/{google_bigquery → bigbroda}/jobs.rb

@@ -1,16 +1,16 @@
-module GoogleBigquery 
-  class Jobs < GoogleBigquery::Client
+module BigBroda
+  class Jobs < BigBroda::Client
 
     def initialize(client=nil, opts={})
       @client = client
     end
 
     #query
-    #Runs a BigQuery SQL query synchronously and returns query results if the query completes within a specified timeout. 
+    #Runs a BigQuery SQL query synchronously and returns query results if the query completes within a specified timeout.
     def self.query(project_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.jobs.query, 
-        :body_object=> body, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.jobs.query,
+        :body_object=> body,
         :parameters=> {"projectId"=> project_id}
       )
       parse_response(res)
@@ -19,8 +19,8 @@ module GoogleBigquery
 
     #Retrieves the specified job by ID.
     def self.get(project_id , job_id)
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.jobs.get, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.jobs.get,
         :parameters=> {"projectId"=> project_id, "jobId"=>job_id}
       )
       parse_response(res)
@@ -28,8 +28,8 @@ module GoogleBigquery
 
     #Retrieves the results of a query job.
     def self.getQueryResults(project_id , job_id, params={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.jobs.get_query_results, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.jobs.get_query_results,
         :parameters=> {"projectId"=> project_id, "jobId"=>job_id}.merge(params)
       )
       parse_response(res)
@@ -37,9 +37,9 @@ module GoogleBigquery
 
     #Starts a new asynchronous job.
     def self.insert(project_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.jobs.insert, 
-        :body_object=> body, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.jobs.insert,
+        :body_object=> body,
         :parameters=> {"projectId"=> project_id}
       )
       parse_response(res)
@@ -47,8 +47,8 @@ module GoogleBigquery
 
     #Lists all the Jobs in the specified project that were started by the user.
     def self.list(project_id, params={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.jobs.list, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.jobs.list,
         :parameters=> {"projectId"=> project_id}.merge(params)
       )
       parse_response(res)
@@ -71,16 +71,16 @@ module GoogleBigquery
        }
       }
 
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.jobs.insert, 
-        :body_object=> body, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.jobs.insert,
+        :body_object=> body,
         :parameters=> {"projectId"=> project_id}
       )
-   
+
       job_id = JSON.parse(res.body)["jobReference"]["jobId"]
       puts 'Waiting for export to complete..'
 
-      loop do 
+      loop do
         status = JSON.parse(self.get(project_id, job_id).body)
 
         if 'DONE' == status['status']['state']
@@ -104,8 +104,8 @@ module GoogleBigquery
         'load'=> {
           'sourceFormat' => "NEWLINE_DELIMITED_JSON",
           'sourceUri' => sources.first,
-          'sourceUris' => sources, 
-          
+          'sourceUris' => sources,
+
           'destinationTable'=> {
             'projectId'=> project_id,
             'datasetId'=> dataset_id,
@@ -114,16 +114,16 @@ module GoogleBigquery
          }
        }
       }
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.jobs.insert, 
-        :body_object=> body, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.jobs.insert,
+        :body_object=> body,
         :parameters=> {"projectId"=> project_id}
       )
       #binding.pry
       job_id = JSON.parse(res.body)["jobReference"]["jobId"]
       puts 'Waiting for import to complete..'
-      
-      loop do 
+
+      loop do
         status = JSON.parse(self.get(project_id, job_id).body)
 
         if 'DONE' == status['status']['state']
@@ -149,7 +149,7 @@ module GoogleBigquery
     private
 
     def self.build_body_object(options)
-      project_id = options[:project_id] 
+      project_id = options[:project_id]
       dataset_id = options[:dataset_id]
       table_id   = options[:table_id]
       bucket_location = options[:bucket_location]

data/lib/bigbroda/project.rb

@@ -0,0 +1,16 @@
+
+module BigBroda
+  class Project < BigBroda::Client
+
+    attr_accessor :options
+
+    def initialize( opts={})
+      super
+    end
+
+    def self.list
+      parse_response BigBroda::Auth.client.execute( BigBroda::Auth.api.projects.list)
+    end
+
+  end
+end

data/lib/{google_bigquery → bigbroda}/railtie.rb

@@ -1,10 +1,10 @@
 # encoding: UTF-8
 
-module GoogleBigquery
+module BigBroda
   class Railtie < ::Rails::Railtie
     config.before_configuration do
       require "#{Rails.root}/config/initializers/bigquery"
-      GoogleBigquery::Auth.new.authorize
+      BigBroda::Auth.new.authorize
     #  if config.action_view.javascript_expansions
     #    config.action_view.javascript_expansions[:high_charts] |= %w(highcharts exporting)
     #  end
@@ -19,7 +19,7 @@ module GoogleBigquery
     rake_tasks do
       require "active_record/base"
       require "active_record/tasks/bigquery_database_tasks"
-      
+
       #ActiveRecord::Tasks::DatabaseTasks.seed_loader = Rails.application
       #ActiveRecord::Tasks::DatabaseTasks.env = Rails.env
 

data/lib/{google_bigquery → bigbroda}/table.rb

@@ -1,59 +1,59 @@
 
-module GoogleBigquery
-  class Table < GoogleBigquery::Client
+module BigBroda
+  class Table < BigBroda::Client
 
-    attr_accessor :options 
+    attr_accessor :options
 
     def initialize( opts={})
       super
     end
 
     def self.list(project_id, dataset_id)
-      parse_response GoogleBigquery::Auth.client.execute( 
-        GoogleBigquery::Auth.api.tables.list,
+      parse_response BigBroda::Auth.client.execute(
+        BigBroda::Auth.api.tables.list,
         projectId: project_id, datasetId: dataset_id
       )
     end
 
     def self.get(project_id, dataset_id, table_id)
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.tables.get, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.tables.get,
         :parameters=> {"projectId"=> project_id, "datasetId"=> dataset_id, "tableId"=> table_id  }
       )
       parse_response(res)
     end
 
     def self.update(project_id, dataset_id, table_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.tables.update, 
-        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}}, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.tables.update,
+        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}},
         :parameters=> {"projectId"=> project_id, "datasetId" => dataset_id, "tableId"=> table_id }
       )
       parse_response(res)
     end
 
     def self.patch(project_id, dataset_id, table_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.tables.update, 
-        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}}, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.tables.update,
+        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}},
         :parameters=> {"projectId"=> project_id, "datasetId" => dataset_id, "tableId"=> table_id }
       )
       parse_response(res)
     end
 
     def self.create(project_id, dataset_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.tables.insert, 
-        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}}, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.tables.insert,
+        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}},
         :parameters=> {"projectId"=> project_id, "datasetId"=> dataset_id }
       )
       parse_response(res)
     end
 
     def self.delete(project_id, dataset_id, table_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.tables.delete, 
-        #:body_object=> body, #{"deleteContents"=> false}, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.tables.delete,
+        #:body_object=> body, #{"deleteContents"=> false},
         :parameters=> {"projectId"=> project_id, "datasetId" => dataset_id, "tableId"=> table_id }
       )
        res.status == 204 ?  true : parse_response(res)

data/lib/{google_bigquery → bigbroda}/table_data.rb

@@ -1,19 +1,19 @@
 
-module GoogleBigquery
-  class TableData < GoogleBigquery::Client
+module BigBroda
+  class TableData < BigBroda::Client
 
     def self.create(project_id, dataset_id, table_id, body={})
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.tabledata.insert_all, 
-        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}}, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.tabledata.insert_all,
+        :body_object=> body , #{"datasetReference"=> {"datasetId" =>"whoa"}},
         :parameters=> {"projectId"=> project_id, "datasetId"=> dataset_id, "tableId"=>table_id }
       )
       parse_response(res)
     end
 
     def self.list(project_id, dataset_id, table_id)
-      res = GoogleBigquery::Auth.client.execute(
-        :api_method=> GoogleBigquery::Auth.api.tabledata.list, 
+      res = BigBroda::Auth.client.execute(
+        :api_method=> BigBroda::Auth.api.tabledata.list,
         :parameters=> {"projectId"=> project_id, "datasetId"=> dataset_id, "tableId"=>table_id }
       )
       parse_response(res)

data/lib/bigbroda/version.rb

@@ -0,0 +1,3 @@
+module BigBroda
+  VERSION = "0.1.0.pre"
+end

data/lib/bigbroda.rb

@@ -0,0 +1,27 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "google/api_client"
+require "active_support"
+
+module BigBroda
+
+  autoload  :VERSION,  'bigbroda/version.rb'
+  autoload  :Config,   'bigbroda/config.rb'
+  autoload  :Auth,     'bigbroda/auth.rb'
+  autoload  :Client,   'bigbroda/client.rb'
+  autoload  :Project,  'bigbroda/project.rb'
+  autoload  :Dataset,  'bigbroda/dataset.rb'
+  autoload  :Table,    'bigbroda/table.rb'
+  autoload  :TableData,'bigbroda/table_data.rb'
+  autoload  :Jobs,     'bigbroda/jobs.rb'
+
+  if defined?(::Rails::Railtie)
+    autoload  :Rails,   'bigbroda/engine.rb' if ::Rails.version >= '3.1'
+  end
+
+  if defined?(::Rails::Railtie)
+    autoload  :Rails,   'bigbroda/engine.rb' if ::Rails.version >= '3.1'
+    require File.join(File.dirname(__FILE__), *%w[bigbroda railtie]) if ::Rails.version.to_s >= '3.1'
+  end
+
+end

data/lib/generators/{google_bigquery → bigbroda}/install/install_generator.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-module GoogleBigquery
+module BigBroda
   class InstallGenerator < ::Rails::Generators::Base
 
     source_root File.expand_path("../../../templates", __FILE__)
@@ -10,7 +10,7 @@ module GoogleBigquery
 
     def copy_initializer
       say_status("installing", "BigQuery", :green)
-      copy_file "bigquery.rb.erb", "config/initializers/bigquery.rb"
+      copy_file "bigquery.rb.erb", "config/initializers/bigbroda.rb"
     end
 
     def show_readme

data/lib/generators/templates/{bigquery.rb.erb → bigbroda.rb.erb}

@@ -1,4 +1,4 @@
-GoogleBigquery::Config.setup do |config|
+BigBroda::Config.setup do |config|
   #config.pass_phrase = "notasecret"
   #config.key_file    = Rails.root + "/config/XXXXkey_file.p12"
   #config.scope       = "https://www.googleapis.com/auth/bigquery"

data/spec/dummy/config/application.rb

@@ -3,7 +3,7 @@ require File.expand_path('../boot', __FILE__)
 require 'rails/all'
 
 Bundler.require(*Rails.groups)
-require "google_bigquery"
+require "big_broda"
 
 module Dummy
   class Application < Rails::Application

data/spec/functional/adapter/adapter_spec.rb

@@ -46,21 +46,21 @@ class RemovePublishedToUser < ActiveRecord::Migration
   end
 end
 
-class User < ActiveRecord::Base 
+class User < ActiveRecord::Base
   validates :name, presence: true
   has_many :posts
 
   scope :admins , ->{where(admin: true)}
 end
 
-class Post < ActiveRecord::Base 
+class Post < ActiveRecord::Base
   validates :title, presence: true
   belongs_to :user
 end
 
 def create_tables
-  @table = GoogleBigquery::Table.create(@project, @name, @table_body )
-  
+  @table = BigBroda::Table.create(@project, @name, @table_body )
+
   @rows =   {"rows"=> [
                         {
                           "insertId"=> Time.now.to_i.to_s,
@@ -69,8 +69,8 @@ def create_tables
                           }
                         }
                       ]}
-                      
-  GoogleBigquery::TableData.create(@project, @name, @table_name , @rows )
+
+  BigBroda::TableData.create(@project, @name, @table_name , @rows )
 end
 
 describe "ActiveRecord Adapter", :vcr => { :allow_unused_http_interactions => true } do
@@ -80,11 +80,11 @@ describe "ActiveRecord Adapter", :vcr => { :allow_unused_http_interactions => tr
   let(:add_col_migration) { AddPublishedToUser.new}
   let(:remove_col_migration) { RemovePublishedToUser.new}
 
-  before :all do 
+  before :all do
 
     VCR.use_cassette("ActiveRecord_Adapter/authorize_config") do
       config_setup
-      @auth = GoogleBigquery::Auth.new
+      @auth = BigBroda::Auth.new
       @auth.authorize
       @name = "rspec_schema"
       @project = config_options["email"].match(/(\d*)/)[0]
@@ -93,8 +93,8 @@ describe "ActiveRecord Adapter", :vcr => { :allow_unused_http_interactions => tr
       @table_body = {  "tableReference"=> {
                           "projectId"=> @project,
                           "datasetId"=> @name,
-                          "tableId"=> @table_name}, 
-                        "schema"=> [:fields=>[ 
+                          "tableId"=> @table_name},
+                        "schema"=> [:fields=>[
                                       {:name=> "id", :type=> "string"},
                                       {:name=> "name", :type=> "string", :mode => "REQUIRED"},
                                       {:name=>  "age", :type=> "integer"},
@@ -105,28 +105,28 @@ describe "ActiveRecord Adapter", :vcr => { :allow_unused_http_interactions => tr
                     }
 
       ActiveRecord::Base.establish_connection(
-        :adapter => 'bigquery', 
+        :adapter => 'bigquery',
         :project => @project,
         :database => @name
       )
     end
   end
 
-  before :each do 
+  before :each do
     VCR.use_cassette("ActiveRecord_Adapter/create_each") do
-      GoogleBigquery::Dataset.create(@project, 
+      BigBroda::Dataset.create(@project,
         {"datasetReference"=> { "datasetId" => @name }} )
-      create_tables     
+      create_tables
     end
   end
 
-  after :each do 
+  after :each do
     VCR.use_cassette("ActiveRecord_Adapter/after_each") do
-      GoogleBigquery::Dataset.delete(@project, @name) 
+      BigBroda::Dataset.delete(@project, @name)
     end
   end
 
-  describe "adapter" do 
+  describe "adapter" do
 
     it "simple quering", :vcr do
       #sleep 50
@@ -137,6 +137,7 @@ describe "ActiveRecord Adapter", :vcr => { :allow_unused_http_interactions => tr
       #User.create(name: "frank capra")
       #User.find_by(id: "some-id-1393025921")
       #User.where("id =? and name= ?", "some-id-1393025921", "User 2014-02-21 20:38:41 -0300")
+
       expect(User.count).to be 1
       expect(User.first).to be_an_instance_of User
       expect(User.all.size).to be 1
@@ -144,15 +145,15 @@ describe "ActiveRecord Adapter", :vcr => { :allow_unused_http_interactions => tr
   end
 
   describe "migrations" do
-    
-    before :each do 
+
+    before :each do
       VCR.use_cassette("ActiveRecord_Adapter/after_each") do
-        GoogleBigquery::Table.delete(@project, @name, "users") 
-        migration.up; User.reset_column_information 
+        BigBroda::Table.delete(@project, @name, "users")
+        migration.up; User.reset_column_information
       end
     end
-   
-    describe '#up', vcr: {:record => :new_episodes} do     
+
+    describe '#up', vcr: {:record => :new_episodes} do
       it 'adds the created_at & updated_at column', :vcr do
         User.columns_hash.should have_key('created_at')
         User.columns_hash.should have_key('updated_at')
@@ -160,43 +161,44 @@ describe "ActiveRecord Adapter", :vcr => { :allow_unused_http_interactions => tr
     end
 
     describe '#down', vcr: {:record => :new_episodes} do
-      before { 
-        migration.down; User.reset_column_information 
+      before {
+        migration.down; User.reset_column_information
       }
-     
+
       it 'adds the email_at_utc_hour column' do
         User.should_not be_table_exists
       end
 
     end
 
-    #describe "add column", vcr: {:record => :new_episodes} do 
-    #  before { 
-    #    add_col_migration.change; User.reset_column_information 
+    #describe "add column", vcr: {:record => :new_episodes} do
+    #  before {
+    #    add_col_migration.change; User.reset_column_information
     #  }
-     
+
     #  it 'adds published column' do
     #    #binding.pry
     #    User.columns_hash.should have_key('published')
     #  end
     #end
 
-    describe "remove column", vcr: {:record => :new_episodes} do 
-      before { 
-        add_col_migration.change; User.reset_column_information 
+    describe "remove column", vcr: {:record => :new_episodes} do
+      before {
+        add_col_migration.change; User.reset_column_information
       }
-     
+
       it 'should raise error' do
         expect{remove_col_migration.change}.to raise_error
       end
     end
 
-    describe "associations", vcr: {:record => :new_episodes} do 
-      before { 
-        posts_migration.up; Post.reset_column_information 
+    describe "associations", vcr: {:record => :new_episodes} do
+      before {
+        posts_migration.up; Post.reset_column_information
       }
 
-      it "users_posts" do 
+      it "users_posts" do
+        #binding.pry
         User.create(name: "ALF")
         #sleep 50
         post = User.first.posts.create(title: "yeah")

data/spec/functional/auth_spec.rb

@@ -3,15 +3,15 @@ require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
 describe "Config" do
   before(:all) do
     config_setup
-    @auth = GoogleBigquery::Auth.new
+    @auth = BigBroda::Auth.new
   end
 
   it "authorization object" do
     VCR.use_cassette('auth') do
       @auth.authorize
       @auth.api.class.should be Google::APIClient::API
-      GoogleBigquery::Auth.api.class.should be Google::APIClient::API
-      GoogleBigquery::Auth.client.class.should be Google::APIClient
+      BigBroda::Auth.api.class.should be Google::APIClient::API
+      BigBroda::Auth.client.class.should be Google::APIClient
     end
   end