facebook_test_users 0.0.2 → 0.1.4

data/README.md

@@ -3,20 +3,79 @@
 Testing Facebook apps is hard; part of that difficulty comes from
 managing your test users. Currently, Facebook's "Developer" app
 doesn't offer any way to do it, so you wind up with a bunch of `curl`
-commands and pain.
+commands and pain (see Facebook's [API
+documentation](https://developers.facebook.com/docs/test_users/) for
+details).
 
 This gem tries to take away the pain of managing your test users. It's
 easy to get started.
 
 `$ gem install facebook_test_users`
 
-`$ fbtu apps add --name myapp --app-id 123456 --app-secret abcdef`
+`$ fbtu apps register --name myapp --app-id 123456 --app-secret abcdef`
 
 `$ fbtu users list --app myapp`
 
-`$ fbtu users add --app myapp`
+`$ fbtu users create --app myapp --name Fred`
+
+`$ fbtu users change --app myapp --user 1000000093284356 --name "Sir Fred"`
+
+`$ fbtu apps add-user --from-app myapp --user 1000000093284356 --to-app myotherapp`
+
+`$ fbtu apps rm-user --app myapp --user 1000000093284356`
 
 `$ fbtu users rm --app myapp --user 1000000093284356`
 
 You can also use it in your own Ruby applications; `require
 "facebook_test_users"` and off you go.
+
+## Integration with Rails apps
+
+It's easy to integrate with Rails apps.  For example, if your app has
+a `"config/omniauth/#{Rails.env}.yml"` file containing:
+
+    facebook:
+      name:       http://localhost:3000
+      API_key:    123456789012
+      app_secret: a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6
+
+and `config/initializers/omniauth.rb` containing:
+
+    omniauth_yml_path = Rails.root.join("config", "omniauth", Rails.env + ".yml")
+    SETTINGS = YAML.load(IO.read(omniauth_yml_path))
+
+    Rails.application.config.middleware.use OmniAuth::Builder do
+      SETTINGS.each do |service, secrets|
+        provider service.to_sym, secrets['API_key'], secrets['app_secret']
+      end
+    end
+
+then you could build simple rake tasks like this:
+
+    require 'facebook_test_users/cli'
+    require File.expand_path "#{Rails.root}/config/initializers/omniauth.rb"
+
+    fb = SETTINGS['facebook']
+    APP_ID = fb['API_key']
+    SECRET = fb['app_secret']
+
+    namespace :fbtu do
+      namespace :app do
+        desc 'Register facebook app credentials with fbtu'
+        task :register do
+          FacebookTestUsers::App.create!(:name => fb['name'], :id => APP_ID, :secret => SECRET)
+          puts "Registered app '#{fb['name']}'"
+        end
+      end
+
+      namespace :users do
+        desc 'List test users via fbtu'
+        task :list do
+          cli = FacebookTestUsers::CLI::Main.start [:users, :list, '--app', fb['name'] ]
+        end
+      end
+    end
+
+Then after running `rake fbtu:app:register`, you can invoke `fbtu`
+commands as per normal, using `--app http://localhost:3000` to refer
+to the registered app.

data/bin/fbtu

@@ -7,4 +7,4 @@ rescue LoadError
   require 'facebook_test_users/cli'
 end
 
-FacebookTestUsers::CLI.start
+FacebookTestUsers::CLI::Main.start

data/facebook_test_users.gemspec

@@ -22,11 +22,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'rest-client', '~> 1.6.1'
-  s.add_dependency 'thor',        '~> 0.14.6'
-  s.add_dependency 'json_pure',   '~> 1.5.0'
+  s.add_dependency 'rest-client', '>= 1.6.1'
+  s.add_dependency 'thor',        '>= 0.14.6'
+  s.add_dependency 'multi_json'
+  s.add_dependency 'heredoc_unindent'
 
   s.add_development_dependency 'fakeweb',         '~>1.3.0'
   s.add_development_dependency 'fakeweb-matcher', '~>1.2.2'
-  s.add_development_dependency 'rspec',           '~> 2.3.0'
+  s.add_development_dependency 'rspec',           '>= 2.3.0'
+  s.add_development_dependency 'json'
 end

data/lib/facebook_test_users/app.rb

@@ -1,29 +1,29 @@
-require 'json'
+require 'multi_json'
 
 module FacebookTestUsers
   class App
 
     attr_reader :name, :id, :secret
-    
+
     def initialize(attrs)
       @name, @id, @secret = attrs[:name].to_s, attrs[:id].to_s, attrs[:secret].to_s
       validate!
     end
-      
+
     def attrs
       {:name => name, :id => id, :secret => secret}
     end
 
     def self.create!(attrs)
-      new_guy = new(attrs)
+      new_app = new(attrs)
 
-      if all.find {|app| app.name == new_guy.name }
-        raise ArgumentError, "App names must be unique, and there is already an app named \"#{new_guy.name}\"."
+      if all.find {|app| app.name == new_app.name }
+        raise ArgumentError, "App names must be unique, and there is already an app named \"#{new_app.name}\"."
       end
 
       DB.update do |data|
         data[:apps] ||= []
-        data[:apps] << new_guy.attrs
+        data[:apps] << new_app.attrs
       end
     end
 
@@ -32,17 +32,29 @@ module FacebookTestUsers
           :access_token => access_token
         })
 
-      JSON[users_data]["data"].map do |user_data|
+      MultiJson.decode(users_data)["data"].map do |user_data|
         User.new(user_data)
       end
     end
 
-    def create_user
-      user_data = RestClient.post(users_url,
-        :access_token => access_token,
-        :installed => true)
+    def create_user(options = {})
+      user_data = RestClient.post(users_url, {:access_token => access_token}.merge(options))
+      User.new(MultiJson.decode(user_data))
+    end
+
+    def add_user(options)
+      raise "add_user called without uid" \
+        unless options.has_key?(:uid)
+      raise "add_user called without owner_access_token" \
+        unless options.has_key?(:owner_access_token)
 
-      User.new(JSON[user_data])
+      user_data = RestClient.post(users_url, {:access_token => access_token}.merge(options))
+      User.new(MultiJson.decode(user_data))
+    end
+
+    def rm_user(uid)
+      url = rm_user_url(uid, access_token)
+      RestClient.delete(url)
     end
 
     ## query methods
@@ -68,6 +80,10 @@ module FacebookTestUsers
       GRAPH_API_BASE + "/#{id}/accounts/test-users"
     end
 
+    def rm_user_url(uid, token)
+      users_url + "?uid=#{uid}&access_token=#{URI.escape(token)}"
+    end
+
     def validate!
       unless name && name =~ /\S/
         raise ArgumentError, "App name must not be empty"

data/lib/facebook_test_users/cli.rb

@@ -1,20 +1,53 @@
 require 'thor'
 require 'facebook_test_users'
+require 'heredoc_unindent'
 
 module FacebookTestUsers
-  class CLI < Thor
-    class Apps < Thor
+  module CLI
+    module Utils
+      def find_app!(name)
+        app = App.find_by_name(name)
+        unless app
+          raise Thor::Error, "Unknown app #{name}. Run 'fbtu apps' to see known apps."
+        end
+        app
+      end
+
+      def bad_request_message(bad_request)
+        response = bad_request.response
+        json = MultiJson.decode(response)
+        json['error']['message'] rescue json.inspect
+      end
 
+      def handle_bad_request(raise_error=true)
+        begin
+          yield
+        rescue RestClient::BadRequest => bad_request
+          @message = bad_request_message(bad_request)
+          raise Thor::Error, "#{bad_request.class}: #@message" if raise_error
+          nil
+        end
+      end
+    end
+
+    class Base < Thor
+      include Utils
+    end
+
+    class Apps < Base
       check_unknown_options!
       def self.exit_on_failure?() true end
 
-      default_task :list
+      # default_task currently breaks subcommand help, so it's
+      # probably better to leave it out for now:
+      # https://github.com/wycats/thor/issues/306
+      #default_task :list
 
-      desc "add", "Tell fbtu about a new application (must already exist on FB)"
+      desc "register", "Tell fbtu about a new application (must already exist on Facebook)"
       method_option "app_id", :type => :string, :required => true, :banner => "OpenGraph ID of the app"
       method_option "app_secret", :type => :string, :required => true, :banner => "App's secret key"
       method_option "name", :type => :string, :required => true, :banner => "Name of the app (so you don't have to remember its ID)"
-      def add
+      def register
         FacebookTestUsers::App.create!(:name => options[:name], :id => options[:app_id], :secret => options[:app_secret])
         list
       end
@@ -26,9 +59,51 @@ module FacebookTestUsers
         end
       end
 
+      desc "add-user", "Add an existing user from another app"
+      method_option   "to_app",    :aliases => %w[-t], :type => :string, :required => true,
+                    :banner => "Name of the application to which user will be added"
+      method_option "from_app",    :aliases => %w[-f], :type => :string, :required => true,
+                    :banner => "Name of the application for which user was originally created"
+      method_option "user",        :aliases => %w[-u], :type => :string, :required => true,
+                    :banner => "User ID to add"
+      method_option "installed",   :aliases => %w[-i], :type => :string, :default => true,
+                    :banner => "Whether your app should be installed for the user"
+      method_option "permissions", :aliases => %w[-p], :type => :string, :default => "read_stream",
+                    :banner => "Permissions the app should be given"
+      def add_user
+        to_app   = find_app!(options[:to_app])
+        from_app = find_app!(options[:from_app])
+        add_user_options = options.select do |k, v|
+          %w[installed permissions].include? k.to_s
+        end
+        add_user_options[:uid] = options[:user]
+        add_user_options[:owner_access_token] = from_app.access_token
+        handle_bad_request do
+          result = to_app.add_user(add_user_options)
+          puts "User #{result.id} added to app '#{options[:to_app]}'"
+        end
+      end
+
+      desc "rm-user", "Remove an existing user from an app"
+      method_option "app", :type => :string, :required => true,
+        :banner => "Name of the application from which user will be removed"
+      method_option "user", :aliases => %w[-u], :type => :string, :required => true,
+        :banner => "User ID to add"
+      def rm_user
+        app  = find_app!(options[:app])
+        result = handle_bad_request do
+          app.rm_user(options[:user])
+        end
+        if result
+          puts "User #{options[:user]} removed from app '#{options[:app]}'"
+        else
+          puts "User #{options[:user]} not removed from app '#{options[:app]}'"
+        end
+      end
+
     end # Apps
 
-    class Users < Thor
+    class Users < Base
       check_unknown_options!
       def self.exit_on_failure?() true end
 
@@ -49,32 +124,112 @@ module FacebookTestUsers
         end
       end
 
-      desc "add", "Add a test user to an application"
-      method_option "app", :aliases => %w[-a], :type => :string, :required => true, :banner => "Name of the app"
+      desc "create", "Create a new test user"
+      method_option "app", :aliases => %w[-a], :type => :string, :required => true,
+                    :banner => "Name of the app"
+      method_option "name", :aliases => %w[-n], :type => :string, :required => false,
+                    :banner => "Name of the new user"
+      method_option "installed", :aliases => %w[-i], :type => :string, :required => false,
+                    :banner => "whether your app should be installed for the test user"
+      method_option "locale", :aliases => %w[-l], :type => :string, :required => false,
+                    :banner => "the locale for the test user"
 
-      def add
+      def create
         app = find_app!(options[:app])
-        user = app.create_user
-        puts "User ID:      #{user.id}"
-        puts "Access Token: #{user.access_token}"
-        puts "Login URL:    #{user.login_url}"
+        attrs = options.select { |k, v| %w(name installed locale).include? k.to_s }
+        user = handle_bad_request do
+          app.create_user(attrs)
+        end
+        if user
+          puts "User ID:      #{user.id}"
+          puts "Access Token: #{user.access_token}"
+          puts "Login URL:    #{user.login_url}"
+          puts "Email:        #{user.email}"
+          puts "Password:     #{user.password}"
+        end
       end
 
       desc "friend", "Make two of an app's users friends"
       method_option "app", :aliases => %w[-a], :type => :string, :required => true, :banner => "Name of the app"
-      method_option "user1", :aliases => %w[-1 -u1], :type => :string, :required => true, :banner => "ID of the first user"
-      method_option "user2", :aliases => %w[-2 -u2], :type => :string, :required => true, :banner => "ID of the second user"
+      method_option "user1", :aliases => %w[-1 -u1], :type => :string, :required => true, :banner => "First user ID"
+      method_option "user2", :aliases => %w[-2 -u2], :type => :string, :required => true, :banner => "Second user ID"
 
       def friend
         app = find_app!(options[:app])
         users = app.users
-        u1 = users.find {|u| u.id.to_s == options[:user1] } or raise ArgumentError, "No user found w/id #{options[:user1].inspect}"
-        u2 = users.find {|u| u.id.to_s == options[:user2] } or raise ArgumentError, "No user found w/id #{options[:user2].inspect}"
+        u1 = users.find {|u| u.id.to_s == options[:user1] } or \
+          raise Thor::Error, "No user found w/id #{options[:user1].inspect}"
+        u2 = users.find {|u| u.id.to_s == options[:user2] } or \
+          raise Thor::Error, "No user found w/id #{options[:user2].inspect}"
+
+        # The first request is just a request; the second request
+        # accepts the first request.
+        handle_bad_request do
+          u1.send_friend_request_to(u2)
+          u2.send_friend_request_to(u1)
+        end
+      end
 
-        # the first request is just a request; the second request
-        # accepts the first request
-        u1.send_friend_request_to(u2)
-        u2.send_friend_request_to(u1)
+      desc "change", "Change a test user's name and/or password"
+      method_option "app", :aliases => %w[-a], :type => :string, :required => true,
+                    :banner => "Name of the app"
+      method_option "user", :aliases => %w[-u], :type => :string, :required => true,
+                    :banner => "ID of the user to change"
+      method_option "name", :aliases => %w[-n], :type => :string, :required => false,
+                    :banner => "New name for the user"
+      method_option "password", :aliases => %w[-n], :type => :string, :required => false,
+                    :banner => "New password for the user"
+
+      def change
+        app = find_app!(options[:app])
+        user = app.users.find do |user|
+          user.id.to_s == options[:user].to_s
+        end
+
+        if user
+          response = handle_bad_request do
+            user.change(options)
+          end
+          if response == "true"
+            puts "Successfully changed user"
+          else
+            puts "Failed to change user"
+          end
+        else
+          raise Thor::Error, "Unknown user '#{options[:user]}'"
+        end
+      end
+
+      desc "list-apps", "List apps associated with the user"
+      method_option "user", :aliases => %w[-u], :type => :string, :required => true,
+                    :banner => "ID of the user for which to list associated apps"
+      method_option "app", :aliases => %w[-a], :type => :string, :required => true,
+                    :banner => "Name of the app owning the user"
+      def list_apps
+        app = find_app!(options[:app])
+        user = app.users.find do |user|
+          user.id.to_s == options[:user].to_s
+        end
+
+        if user
+          response = handle_bad_request do
+            user.owner_apps(app)
+          end
+          if response
+            json = MultiJson.decode(response)
+            apps = json['data'] rescue nil
+            if apps
+              shell.print_table([
+                                  ['App name', 'App ID'],
+                                  *(apps.map { |app| [app['name'], app['id']] })
+                                ])
+            else
+              $stderr.write("No apps returned; response was: #{response}\n")
+            end
+          end
+        else
+          raise Thor::Error, "Unknown user '#{options[:user]}'"
+        end
       end
 
       desc "rm", "Remove a test user from an application"
@@ -88,10 +243,32 @@ module FacebookTestUsers
         end
 
         if user
-          user.destroy
+          result = handle_bad_request(raise_error=false) do
+            user.destroy
+          end
+          if result
+            puts "User ID #{user.id} removed"
+          else
+            if @message.match /(\(#2903\) Cannot delete this test account because it is associated with other applications.)/
+              error = <<-EOMSG.unindent.gsub(/^\|/, '')
+              #$1
+              Run:
+              |
+                fbtu users list-apps --app #{options[:app]} --user #{user.id}
+              |
+              then for each of the other apps, run:
+              |
+                fbtu apps rm-user --app APP-NAME --user #{user.id}
+              |
+              Then re-run this command.
+              EOMSG
+            else
+              error = @message
+            end
+            raise Thor::Error, error
+          end
         else
-          $stderr.write("Unknown user '#{options[:user]}'")
-          raise ArgumentError, "No such user"
+          raise Thor::Error, "Unknown user '#{options[:user]}'"
         end
       end
 
@@ -103,26 +280,17 @@ module FacebookTestUsers
         app.users.each(&:destroy)
       end
 
-      private
-      def find_app!(name)
-        app = App.find_by_name(options[:app])
-        unless app
-          $stderr.puts "Unknown app #{options[:app]}."
-          $stderr.puts "Run 'fbtu apps' to see known apps."
-          raise ArgumentError, "No such app"
-        end
-        app
-      end
-
     end # Users
 
-    check_unknown_options!
-    def self.exit_on_failure?() true end
+    class Main < Thor
+      check_unknown_options!
+      def self.exit_on_failure?() true end
 
-    desc "apps", "Commands for managing FB applications"
-    subcommand :apps, FacebookTestUsers::CLI::Apps
+      desc "apps", "Commands for managing FB applications"
+      subcommand :apps, Apps
 
-    desc "apps", "Commands for managing FB applications' test users"
-    subcommand :users, FacebookTestUsers::CLI::Users
+      desc "users", "Commands for managing FB applications test users"
+      subcommand :users, Users
+    end
   end
 end