Merge pull request #194 from fastlane/get-udids

Add firebase_app_distribution_get_udids action

Author: lfkellogg

lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_get_udids.rb

@@ -0,0 +1,97 @@
+require 'fastlane/action'
+require 'open3'
+require 'shellwords'
+require 'googleauth'
+require_relative '../helper/firebase_app_distribution_helper'
+require_relative '../helper/firebase_app_distribution_error_message'
+require_relative '../client/firebase_app_distribution_api_client'
+require_relative '../helper/firebase_app_distribution_auth_client'
+
+module Fastlane
+  module Actions
+    class FirebaseAppDistributionGetUdidsAction < Action
+      extend Auth::FirebaseAppDistributionAuthClient
+      extend Helper::FirebaseAppDistributionHelper
+
+      def self.run(params)
+        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
+        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, params[:debug])
+
+        app_id = params[:app]
+        udids = fad_api_client.get_udids(app_id)
+
+        if udids.empty?
+          UI.important("App Distribution fetched 0 tester UDIDs. Nothing written to output file.")
+        else
+          write_udids_to_file(udids, params[:output_file])
+          UI.success("🎉 App Distribution tester UDIDs written to: #{params[:output_file]}")
+        end
+      end
+
+      def self.write_udids_to_file(udids, output_file)
+        File.open(output_file, 'w') do |f|
+          f.write("Device ID\tDevice Name\tDevice Platform\n")
+          udids.each do |tester_udid|
+            f.write("#{tester_udid[:udid]}\t#{tester_udid[:name]}\t#{tester_udid[:platform]}\n")
+          end
+        end
+      end
+
+      def self.description
+        "Download the UDIDs of your Firebase App Distribution testers"
+      end
+
+      def self.authors
+        ["Lee Kellogg"]
+      end
+
+      # supports markdown.
+      def self.details
+        "Export your testers' device identifiers in a CSV file, so you can add them your provisioning profile. This file can be imported into your Apple developer account using the Register Multiple Devices option. See the [App Distribution docs](https://firebase.google.com/docs/app-distribution/ios/distribute-console#register-tester-devices) for more info."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :app,
+                                       env_name: "FIREBASEAPPDISTRO_APP",
+                                       description: "Your app's Firebase App ID. You can find the App ID in the Firebase console, on the General Settings page",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :output_file,
+                                       env_name: "FIREBASEAPPDISTRO_OUTPUT_FILE",
+                                       description: "The path to the file where the tester UDIDs will be written",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :firebase_cli_token,
+                                       description: "Auth token for firebase cli",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_file,
+                                       description: "Path to Google service account json",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :debug,
+                                       description: "Print verbose debug output",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios].include?(platform)
+      end
+
+      def self.example_code
+        [
+          <<-CODE
+            firebase_app_distribution_get_udids(
+              app: "1:1234567890:ios:0a1b2c3d4e5f67890",
+              output_file: "tester_udids.txt",
+            )
+          CODE
+        ]
+      end
+    end
+  end
+end

lib/fastlane/plugin/firebase_app_distribution/client/firebase_app_distribution_api_client.rb

@@ -180,6 +180,23 @@ def get_upload_status(app_id, upload_token)
         return UploadStatusResponse.new(response.body)
       end
 
+      # Get tester UDIDs
+      #
+      # args
+      #   app_id - Firebase App ID
+      #
+      # Returns a list of hashes containing tester device info
+      def get_udids(app_id)
+        begin
+          response = connection.get(get_udids_url(app_id)) do |request|
+            request.headers[AUTHORIZATION] = "Bearer " + @auth_token
+          end
+        rescue Faraday::ResourceNotFound
+          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+        end
+        response.body[:testerUdids] || []
+      end
+
       private
 
       def v1_apps_url(app_id)
@@ -202,6 +219,10 @@ def upload_status_url(app_id, app_token)
         "#{v1_apps_url(app_id)}/upload_status/#{app_token}"
       end
 
+      def get_udids_url(app_id)
+        "#{v1_apps_url(app_id)}/testers:getTesterUdids"
+      end
+
       def get_upload_token(project_number, app_id, binary_path)
         binary_hash = Digest::SHA256.hexdigest(read_binary(binary_path))
         CGI.escape("projects/#{project_number}/apps/#{app_id}/releases/-/binaries/#{binary_hash}")

lib/fastlane/plugin/firebase_app_distribution/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module FirebaseAppDistribution
-    VERSION = "0.2.6.pre.1"
+    VERSION = "0.2.7.pre.1"
   end
 end

spec/firebase_app_distribution_api_client_spec.rb

@@ -345,6 +345,39 @@
     end
   end
 
+  describe '#get_udids' do
+    let(:udids) do
+      [
+        { udid: 'device-udid-1', name: 'device-name-1', platform: 'ios' },
+        { udid: 'device-udid-1', name: 'device-name-1', platform: 'ios' }
+      ]
+    end
+
+    it 'returns the list of UDIDs when the get call is successfull' do
+      stubs.get("/v1alpha/apps/app_id/testers:getTesterUdids", headers) do |env|
+        [
+          200,
+          {},
+          { testerUdids: udids }
+        ]
+      end
+      result = api_client.get_udids("app_id")
+      expect(result).to eq(udids)
+    end
+
+    it 'returns an empty list UDIDs when there are no udids' do
+      stubs.get("/v1alpha/apps/app_id/testers:getTesterUdids", headers) do |env|
+        [
+          200,
+          {},
+          {}
+        ]
+      end
+      result = api_client.get_udids("app_id")
+      expect(result).to eq([])
+    end
+  end
+
   describe '#enable_access' do
     it 'posts successfully when tester emails and groupIds are defined' do
       payload = { emails: ["testers"], groupIds: ["groups"] }

spec/firebase_app_distribution_get_udids_spec.rb

@@ -0,0 +1,69 @@
+require 'fastlane/action'
+
+describe Fastlane::Actions::FirebaseAppDistributionGetUdidsAction do
+  let(:action) { Fastlane::Actions::FirebaseAppDistributionGetUdidsAction }
+  let(:app_id) { '1:1234567890:android:321abc456def7890' }
+  let(:mock_file) { StringIO.new }
+  let(:output_file_path) { '/path/to/output/file.txt' }
+
+  describe '#run' do
+    describe 'when there are testers with udids' do
+      before(:each) do
+        allow(action).to receive(:fetch_auth_token).and_return('fake-auth-token')
+        allow_any_instance_of(Fastlane::Client::FirebaseAppDistributionApiClient)
+          .to receive(:get_udids)
+          .with(app_id)
+          .and_return(
+            [
+              {
+                udid: 'device-udid-1',
+                name: 'device-name-1',
+                platform: 'ios'
+              },
+              {
+                udid: 'device-udid-2',
+                name: 'device-name-2',
+                platform: 'ios'
+              }
+            ]
+          )
+      end
+
+      let(:params) do
+        {
+          app: app_id,
+          output_file: output_file_path
+        }
+      end
+
+      it 'writes UDIDs to file' do
+        expect(File).to receive(:open).with(output_file_path, 'w').and_yield(mock_file)
+        action.run(params)
+        expect(mock_file.string).to eq("Device ID\tDevice Name\tDevice Platform\ndevice-udid-1\tdevice-name-1\tios\ndevice-udid-2\tdevice-name-2\tios\n")
+      end
+    end
+  end
+
+  describe 'when there are no testers with udids' do
+    before(:each) do
+      allow(action).to receive(:fetch_auth_token).and_return('fake-auth-token')
+      allow_any_instance_of(Fastlane::Client::FirebaseAppDistributionApiClient)
+        .to receive(:get_udids)
+        .with(app_id)
+        .and_return([])
+    end
+
+    let(:params) do
+      {
+        app: app_id,
+        output_file: output_file_path
+      }
+    end
+
+    it 'does not write to file' do
+      allow(File).to receive(:open).and_yield(mock_file)
+      action.run(params)
+      expect(File).not_to(have_received(:open))
+    end
+  end
+end