Skip to content

A platform for community discussion. Free, open, simple.

8.1 KB
Raw Blame
# frozen_string_literal: true

def auth_token_for(user)
  {
    provider: "github",
    extra: {
      all_emails: [{ email: user.email, primary: true, verified: true }],
    },
    info: {
      email: user.email,
      nickname: user.username,
      name: user.name,
      image: "https://avatars3.githubusercontent.com/u/#{user.username}",
    },
    uid: "100",
  }
end

RSpec.describe Auth::GithubAuthenticator do
  let(:authenticator) { described_class.new }

  fab!(:user)

  describe "after_authenticate" do
    let(:data) { auth_token_for(user) }

    it "can authenticate and create a user record for already existing users" do
      result = authenticator.after_authenticate(data)

      expect(result.user.id).to eq(user.id)
      expect(result.username).to eq(user.username)
      expect(result.name).to eq(user.name)
      expect(result.email).to eq(user.email)
      expect(result.email_valid).to eq(true)

      # Authenticates again when user has GitHub user info
      result = authenticator.after_authenticate(data)

      expect(result.email).to eq(user.email)
      expect(result.email_valid).to eq(true)
    end

    it "can authenticate and update GitHub screen_name for existing user" do
      UserAssociatedAccount.create!(
        user_id: user.id,
        provider_name: "github",
        provider_uid: 100,
        info: {
          nickname: "boris",
        },
      )

      result = authenticator.after_authenticate(data)

      expect(result.user.id).to eq(user.id)
      expect(result.email).to eq(user.email)
      expect(result.email_valid).to eq(true)
      expect(
        UserAssociatedAccount.find_by(provider_name: "github", user_id: user.id).info["nickname"],
      ).to eq(user.username)
    end

    it "uses the primary email when creating a user" do
      hash = {
        provider: "github",
        extra: {
          all_emails: [
            { email: "[email protected]", primary: false, verified: true },
            { email: "[email protected]", primary: true, verified: true },
          ],
        },
        info: {
          email: "[email protected]",
          nickname: "john",
          name: "John Bob",
        },
        uid: "100",
      }

      result = authenticator.after_authenticate(hash)

      expect(result.email).to eq("[email protected]")
    end

    it "handles a user with a different GitHub account already attached" do
      # There is a rare case where an end user had
      # 2 different github accounts and moved emails between the 2

      UserAssociatedAccount.create!(
        user_id: user.id,
        info: {
          nickname: "bob",
        },
        provider_uid: 100,
        provider_name: "github",
      )

      hash = {
        provider: "github",
        extra: {
          all_emails: [{ email: user.email, primary: false, verified: true }],
        },
        info: {
          email: "[email protected]",
          nickname: "john",
          name: "John Bob",
        },
        uid: "1001",
      }

      result = authenticator.after_authenticate(hash)

      expect(result.user.id).to eq(user.id)
      expect(UserAssociatedAccount.where(user_id: user.id).pluck(:provider_uid)).to eq(["1001"])
    end

    it "does not authenticate existing users with an unverified email" do
      hash = {
        provider: "github",
        extra: {
          all_emails: [{ email: user.email, primary: true, verified: false }],
        },
        info: {
          email: user.email,
          nickname: user.username,
          name: user.name,
        },
        uid: "100",
      }

      result = authenticator.after_authenticate(hash)

      expect(result.user).to eq(nil)
      expect(result.username).to eq(user.username)
      expect(result.name).to eq(user.name)
      expect(result.email).to eq(user.email)
      expect(result.email_valid).to eq(false)
    end

    it "can create a proper result for non existing users" do
      hash = {
        provider: "github",
        extra: {
          all_emails: [{ email: "[email protected]", primary: true, verified: true }],
        },
        info: {
          email: "[email protected]",
          nickname: "person",
          name: "Person Lastname",
        },
        uid: "100",
      }

      result = authenticator.after_authenticate(hash)

      expect(result.user).to eq(nil)
      expect(result.username).to eq(hash[:info][:nickname])
      expect(result.name).to eq(hash[:info][:name])
      expect(result.email).to eq(hash[:info][:email])
      expect(result.email_valid).to eq(hash[:info][:email].present?)
    end

    it "skips blocklisted domains for new users" do
      hash = {
        provider: "github",
        extra: {
          all_emails: [
            { email: "[email protected]", primary: true, verified: true },
            { email: "[email protected]", primary: false, verified: true },
          ],
        },
        info: {
          email: "[email protected]",
          nickname: "person",
          name: "Person Lastname",
        },
        uid: "100",
      }

      SiteSetting.blocked_email_domains = "blocklist.com"
      result = authenticator.after_authenticate(hash)

      expect(result.user).to eq(nil)
      expect(result.username).to eq(hash[:info][:nickname])
      expect(result.name).to eq(hash[:info][:name])
      expect(result.email).to eq("[email protected]")
      expect(result.email_valid).to eq(true)
    end

    it "finds allowlisted domains for new users" do
      hash = {
        provider: "github",
        extra: {
          all_emails: [
            { email: "[email protected]", primary: true, verified: true },
            { email: "[email protected]", primary: false, verified: true },
            { email: "[email protected]", primary: false, verified: true },
          ],
        },
        info: {
          email: "[email protected]",
          nickname: "person",
          name: "Person Lastname",
        },
        uid: "100",
      }

      SiteSetting.allowed_email_domains = "allowlist.com"
      result = authenticator.after_authenticate(hash)

      expect(result.user).to eq(nil)
      expect(result.username).to eq(hash[:info][:nickname])
      expect(result.name).to eq(hash[:info][:name])
      expect(result.email).to eq("[email protected]")
      expect(result.email_valid).to eq(true)
    end

    it "can connect to a different existing user account" do
      user1 = Fabricate(:user)
      user2 = Fabricate(:user)

      expect(authenticator.can_connect_existing_user?).to eq(true)

      UserAssociatedAccount.create!(
        provider_name: "github",
        user_id: user1.id,
        provider_uid: 100,
        info: {
          nickname: "boris",
        },
      )

      result = authenticator.after_authenticate(data, existing_account: user2)

      expect(result.user.id).to eq(user2.id)
      expect(UserAssociatedAccount.exists?(user_id: user1.id)).to eq(false)
      expect(UserAssociatedAccount.exists?(user_id: user2.id)).to eq(true)
    end
  end

  describe "revoke" do
    fab!(:user)
    let(:authenticator) { Auth::GithubAuthenticator.new }

    it "raises exception if no entry for user" do
      expect { authenticator.revoke(user) }.to raise_error(Discourse::NotFound)
    end

    it "revokes correctly" do
      UserAssociatedAccount.create!(
        provider_name: "github",
        user_id: user.id,
        provider_uid: 100,
        info: {
          nickname: "boris",
        },
      )
      expect(authenticator.can_revoke?).to eq(true)
      expect(authenticator.revoke(user)).to eq(true)
      expect(authenticator.description_for_user(user)).to eq("")
    end
  end

  describe "avatar retrieval" do
    it "queues the GitHub picture for its associated account" do
      expect { authenticator.after_authenticate(auth_token_for(user)) }.to change {
        Jobs::DownloadAvatarFromUrl.jobs.size
      }.by(1)

      account = user.user_associated_accounts.find_by!(provider_name: "github")

      expect(Jobs::DownloadAvatarFromUrl.jobs.last["args"].first).to include(
        "url" => "https://avatars3.githubusercontent.com/u/#{user.username}",
        "user_id" => user.id,
        "associated_account_id" => account.id,
      )
    end
  end
end