No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
	index dc85eaba2..2b2601082 100644
	--- a/.gitlab-ci.yml
	+++ b/.gitlab-ci.yml
	@@ -1,266 +1,315 @@
	image: elixir:1.8.1

	variables: &global_variables
	POSTGRES_DB: pleroma_test
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres
	DB_HOST: postgres
	MIX_ENV: test

	cache: &global_cache_policy
	key: ${CI_COMMIT_REF_SLUG}
	paths:
	- - deps
	- - _build
	+ - deps
	+ - _build
	+
	stages:
	- build
	- test
	- benchmark
	- deploy
	- release
	+ - docker

	before_script:
	- mix local.hex --force
	- mix local.rebar --force

	build:
	stage: build
	script:
	- mix deps.get
	- mix compile --force

	benchmark:
	stage: benchmark
	when: manual
	variables:
	MIX_ENV: benchmark
	services:
	- name: postgres:9.6
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- mix deps.get
	- mix ecto.create
	- mix ecto.migrate
	- mix pleroma.load_testing

	unit-testing:
	stage: test
	cache: &testing_cache_policy
	<<: *global_cache_policy
	policy: pull

	services:
	- name: postgres:9.6
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- mix deps.get
	- mix ecto.create
	- mix ecto.migrate
	- mix coveralls --preload-modules

	federated-testing:
	stage: test
	cache: *testing_cache_policy
	services:
	- name: minibikini/postgres-with-rum:12
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- mix deps.get
	- mix ecto.create
	- mix ecto.migrate
	- epmd -daemon
	- mix test --trace --only federated

	unit-testing-rum:
	stage: test
	cache: *testing_cache_policy
	services:
	- name: minibikini/postgres-with-rum:12
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	variables:
	<<: *global_variables
	RUM_ENABLED: "true"
	script:
	- mix deps.get
	- mix ecto.create
	- mix ecto.migrate
	- "mix ecto.migrate --migrations-path priv/repo/optional_migrations/rum_indexing/"
	- mix test --preload-modules

	lint:
	stage: test
	cache: *testing_cache_policy
	script:
	- mix format --check-formatted

	analysis:
	stage: test
	cache: *testing_cache_policy
	script:
	- mix deps.get
	- mix credo --strict --only=warnings,todo,fixme,consistency,readability

	docs-deploy:
	stage: deploy
	cache: *testing_cache_policy
	image: alpine:latest
	only:
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	before_script:
	- apk add curl
	script:
	- curl -X POST -F"token=$DOCS_PIPELINE_TRIGGER" -F'ref=master' -F"variables[BRANCH]=$CI_COMMIT_REF_NAME" https://git.pleroma.social/api/v4/projects/673/trigger/pipeline
	review_app:
	image: alpine:3.9
	stage: deploy
	before_script:
	- apk update && apk add openssh-client git
	when: manual
	environment:
	name: review/$CI_COMMIT_REF_NAME
	url: https://$CI_ENVIRONMENT_SLUG.pleroma.online/
	on_stop: stop_review_app
	only:
	- branches
	except:
	- master
	- develop
	script:
	- echo "$CI_ENVIRONMENT_SLUG"
	- mkdir -p ~/.ssh
	- eval $(ssh-agent -s)
	- echo "$SSH_PRIVATE_KEY" \| tr -d '\r' \| ssh-add -
	- ssh-keyscan -H "pleroma.online" >> ~/.ssh/known_hosts
	- (ssh -t dokku@pleroma.online -- apps:create "$CI_ENVIRONMENT_SLUG") \|\| true
	- (ssh -t dokku@pleroma.online -- git:set "$CI_ENVIRONMENT_SLUG" keep-git-dir true) \|\| true
	- ssh -t dokku@pleroma.online -- config:set "$CI_ENVIRONMENT_SLUG" APP_NAME="$CI_ENVIRONMENT_SLUG" APP_HOST="$CI_ENVIRONMENT_SLUG.pleroma.online" MIX_ENV=dokku
	- (ssh -t dokku@pleroma.online -- postgres:create $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db) \|\| true
	- (ssh -t dokku@pleroma.online -- postgres:link $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db "$CI_ENVIRONMENT_SLUG") \|\| true
	- (ssh -t dokku@pleroma.online -- certs:add "$CI_ENVIRONMENT_SLUG" /home/dokku/server.crt /home/dokku/server.key) \|\| true
	- git push -f dokku@pleroma.online:$CI_ENVIRONMENT_SLUG $CI_COMMIT_SHA:refs/heads/master

	stop_review_app:
	image: alpine:3.9
	stage: deploy
	before_script:
	- apk update && apk add openssh-client git
	when: manual
	environment:
	name: review/$CI_COMMIT_REF_NAME
	action: stop
	script:
	- echo "$CI_ENVIRONMENT_SLUG"
	- mkdir -p ~/.ssh
	- eval $(ssh-agent -s)
	- echo "$SSH_PRIVATE_KEY" \| tr -d '\r' \| ssh-add -
	- ssh-keyscan -H "pleroma.online" >> ~/.ssh/known_hosts
	- ssh -t dokku@pleroma.online -- --force apps:destroy "$CI_ENVIRONMENT_SLUG"
	- ssh -t dokku@pleroma.online -- --force postgres:destroy $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db

	amd64:
	stage: release
	# TODO: Replace with upstream image when 1.9.0 comes out
	image: rinpatch/elixir:1.9.0-rc.0
	only: &release-only
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	- /^maint/.*$/@pleroma/pleroma
	- /^release/.*$/@pleroma/pleroma
	artifacts: &release-artifacts
	name: "pleroma-$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA-$CI_JOB_NAME"
	paths:
	- release/*
	# Ideally it would be never for master branch and with the next commit for develop,
	# but Gitlab does not support neither `only` for artifacts
	# nor setting it to never from .gitlab-ci.yml
	# nor expiring with the next commit
	expire_in: 42 yrs

	cache: &release-cache
	key: $CI_COMMIT_REF_NAME-$CI_JOB_NAME
	paths:
	- deps
	variables: &release-variables
	MIX_ENV: prod
	before_script: &before-release
	- echo "import Mix.Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: &release
	- mix deps.get --only prod
	- mkdir release
	- export PLEROMA_BUILD_BRANCH=$CI_COMMIT_REF_NAME
	- mix release --path release


	amd64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	# TODO: Replace with upstream image when 1.9.0 comes out
	image: rinpatch/elixir:1.9.0-rc.0-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: &before-release-musl
	- apk add git gcc g++ musl-dev make
	- echo "import Mix.Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: *release

	arm:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32
	# TODO: Replace with upstream image when 1.9.0 comes out
	image: rinpatch/elixir:1.9.0-rc.0-arm
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32
	# TODO: Replace with upstream image when 1.9.0 comes out
	image: rinpatch/elixir:1.9.0-rc.0-arm-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release

	arm64:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	# TODO: Replace with upstream image when 1.9.0 comes out
	image: rinpatch/elixir:1.9.0-rc.0-arm64
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	# TODO: Replace with upstream image when 1.9.0 comes out
	image: rinpatch/elixir:1.9.0-rc.0-arm64-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release
	+
	+docker:
	+ stage: docker
	+ image: docker:latest
	+ cache: {}
	+ dependencies: []
	+ variables: &docker-variables
	+ DOCKER_DRIVER: overlay2
	+ DOCKER_HOST: unix:///var/run/docker.sock
	+ IMAGE_TAG: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
	+ IMAGE_TAG_SLUG: $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG
	+ IMAGE_TAG_LATEST: $CI_REGISTRY_IMAGE:latest
	+ IMAGE_TAG_LATEST_STABLE: $CI_REGISTRY_IMAGE:latest-stable
	+ before_script: &before-docker
	+ - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
	+ - export CI_JOB_TIMESTAMP=$(date --utc -Iseconds)
	+ - export CI_VCS_REF=$CI_COMMIT_SHORT_SHA
	+ allow_failure: true
	+ script:
	+ - docker pull $IMAGE_TAG_SLUG \|\| true
	+ - docker build --cache-from $IMAGE_TAG_SLUG --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP -t $IMAGE_TAG -t $IMAGE_TAG_SLUG -t $IMAGE_TAG_LATEST .
	+ - docker push $IMAGE_TAG
	+ - docker push $IMAGE_TAG_SLUG
	+ - docker push $IMAGE_TAG_LATEST
	+ tags:
	+ - dind
	+ only:
	+ - develop
	+
	+docker-stable:
	+ stage: docker
	+ image: docker:latest
	+ cache: {}
	+ dependencies: []
	+ variables: *docker-variables
	+ before_script: *before-docker
	+ allow_failure: true
	+ script:
	+ - docker pull $IMAGE_TAG_SLUG \|\| true
	+ - docker build --cache-from $IMAGE_TAG_SLUG --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP -t $IMAGE_TAG -t $IMAGE_TAG_SLUG -t $IMAGE_TAG_LATEST_STABLE .
	+ - docker push $IMAGE_TAG
	+ - docker push $IMAGE_TAG_SLUG
	+ - docker push $IMAGE_TAG_LATEST_STABLE
	+ tags:
	+ - dind
	+ only:
	+ - stable
	diff --git a/Dockerfile b/Dockerfile
	index c61dcfde9..4f7f12716 100644
	--- a/Dockerfile
	+++ b/Dockerfile
	@@ -1,39 +1,53 @@
	FROM elixir:1.9-alpine as build

	COPY . .

	ENV MIX_ENV=prod

	RUN apk add git gcc g++ musl-dev make &&\
	echo "import Mix.Config" > config/prod.secret.exs &&\
	mix local.hex --force &&\
	mix local.rebar --force &&\
	mix deps.get --only prod &&\
	mkdir release &&\
	mix release --path release

	FROM alpine:3.9

	+ARG BUILD_DATE
	+ARG VCS_REF
	+
	+LABEL maintainer="ops@pleroma.social" \
	+ org.opencontainers.image.title="pleroma" \
	+ org.opencontainers.image.description="Pleroma for Docker" \
	+ org.opencontainers.image.authors="ops@pleroma.social" \
	+ org.opencontainers.image.vendor="pleroma.social" \
	+ org.opencontainers.image.documentation="https://git.pleroma.social/pleroma/pleroma" \
	+ org.opencontainers.image.licenses="AGPL-3.0" \
	+ org.opencontainers.image.url="https://pleroma.social" \
	+ org.opencontainers.image.revision=$VCS_REF \
	+ org.opencontainers.image.created=$BUILD_DATE
	+
	ARG HOME=/opt/pleroma
	ARG DATA=/var/lib/pleroma

	RUN echo "http://nl.alpinelinux.org/alpine/latest-stable/community" >> /etc/apk/repositories &&\
	apk update &&\
	apk add ncurses postgresql-client &&\
	adduser --system --shell /bin/false --home ${HOME} pleroma &&\
	mkdir -p ${DATA}/uploads &&\
	mkdir -p ${DATA}/static &&\
	chown -R pleroma ${DATA} &&\
	mkdir -p /etc/pleroma &&\
	chown -R pleroma /etc/pleroma

	USER pleroma

	COPY --from=build --chown=pleroma:0 /release ${HOME}

	COPY ./config/docker.exs /etc/pleroma/config.exs
	COPY ./docker-entrypoint.sh ${HOME}

	EXPOSE 4000

	ENTRYPOINT ["/opt/pleroma/docker-entrypoint.sh"]
	diff --git a/test/web/twitter_api/util_controller_test.exs b/test/web/twitter_api/util_controller_test.exs
	index 8418fd071..5d60c0d51 100644
	--- a/test/web/twitter_api/util_controller_test.exs
	+++ b/test/web/twitter_api/util_controller_test.exs
	@@ -1,675 +1,673 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	- alias Pleroma.Web.CommonAPI

	- import ExUnit.CaptureLog
	import Pleroma.Factory
	import Mock

	setup do
	Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	clear_config([:instance])
	clear_config([:frontend_configurations, :pleroma_fe])
	clear_config([:user, :deny_follow_blocked])

	describe "POST /api/pleroma/follow_import" do
	setup do: oauth_access(["follow"])

	test "it returns HTTP 200", %{conn: conn} do
	user2 = insert(:user)

	response =
	conn
	\|> post("/api/pleroma/follow_import", %{"list" => "#{user2.ap_id}"})
	\|> json_response(:ok)

	assert response == "job started"
	end

	test "it imports follow lists from file", %{user: user1, conn: conn} do
	user2 = insert(:user)

	with_mocks([
	{File, [],
	read!: fn "follow_list.txt" ->
	"Account address,Show boosts\n#{user2.ap_id},true"
	end}
	]) do
	response =
	conn
	\|> post("/api/pleroma/follow_import", %{"list" => %Plug.Upload{path: "follow_list.txt"}})
	\|> json_response(:ok)

	assert response == "job started"

	assert ObanHelpers.member?(
	%{
	"op" => "follow_import",
	"follower_id" => user1.id,
	"followed_identifiers" => [user2.ap_id]
	},
	all_enqueued(worker: Pleroma.Workers.BackgroundWorker)
	)
	end
	end

	test "it imports new-style mastodon follow lists", %{conn: conn} do
	user2 = insert(:user)

	response =
	conn
	\|> post("/api/pleroma/follow_import", %{
	"list" => "Account address,Show boosts\n#{user2.ap_id},true"
	})
	\|> json_response(:ok)

	assert response == "job started"
	end

	test "requires 'follow' or 'write:follows' permissions" do
	token1 = insert(:oauth_token, scopes: ["read", "write"])
	token2 = insert(:oauth_token, scopes: ["follow"])
	token3 = insert(:oauth_token, scopes: ["something"])
	another_user = insert(:user)

	for token <- [token1, token2, token3] do
	conn =
	build_conn()
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> post("/api/pleroma/follow_import", %{"list" => "#{another_user.ap_id}"})

	if token == token3 do
	assert %{"error" => "Insufficient permissions: follow \| write:follows."} ==
	json_response(conn, 403)
	else
	assert json_response(conn, 200)
	end
	end
	end
	end

	describe "POST /api/pleroma/blocks_import" do
	# Note: "follow" or "write:blocks" permission is required
	setup do: oauth_access(["write:blocks"])

	test "it returns HTTP 200", %{conn: conn} do
	user2 = insert(:user)

	response =
	conn
	\|> post("/api/pleroma/blocks_import", %{"list" => "#{user2.ap_id}"})
	\|> json_response(:ok)

	assert response == "job started"
	end

	test "it imports blocks users from file", %{user: user1, conn: conn} do
	user2 = insert(:user)
	user3 = insert(:user)

	with_mocks([
	{File, [], read!: fn "blocks_list.txt" -> "#{user2.ap_id} #{user3.ap_id}" end}
	]) do
	response =
	conn
	\|> post("/api/pleroma/blocks_import", %{"list" => %Plug.Upload{path: "blocks_list.txt"}})
	\|> json_response(:ok)

	assert response == "job started"

	assert ObanHelpers.member?(
	%{
	"op" => "blocks_import",
	"blocker_id" => user1.id,
	"blocked_identifiers" => [user2.ap_id, user3.ap_id]
	},
	all_enqueued(worker: Pleroma.Workers.BackgroundWorker)
	)
	end
	end
	end

	describe "PUT /api/pleroma/notification_settings" do
	setup do: oauth_access(["write:accounts"])

	test "it updates notification settings", %{user: user, conn: conn} do
	conn
	\|> put("/api/pleroma/notification_settings", %{
	"followers" => false,
	"bar" => 1
	})
	\|> json_response(:ok)

	user = refresh_record(user)

	assert %Pleroma.User.NotificationSetting{
	followers: false,
	follows: true,
	non_follows: true,
	non_followers: true,
	privacy_option: false
	} == user.notification_settings
	end

	test "it updates notification privacy option", %{user: user, conn: conn} do
	conn
	\|> put("/api/pleroma/notification_settings", %{"privacy_option" => "1"})
	\|> json_response(:ok)

	user = refresh_record(user)

	assert %Pleroma.User.NotificationSetting{
	followers: true,
	follows: true,
	non_follows: true,
	non_followers: true,
	privacy_option: true
	} == user.notification_settings
	end
	end

	describe "GET /api/statusnet/config" do
	test "it returns config in xml format", %{conn: conn} do
	instance = Pleroma.Config.get(:instance)

	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/api/statusnet/config")
	\|> response(:ok)

	assert response ==
	"<config>\n<site>\n<name>#{Keyword.get(instance, :name)}</name>\n<site>#{
	Pleroma.Web.base_url()
	}</site>\n<textlimit>#{Keyword.get(instance, :limit)}</textlimit>\n<closed>#{
	!Keyword.get(instance, :registrations_open)
	}</closed>\n</site>\n</config>\n"
	end

	test "it returns config in json format", %{conn: conn} do
	instance = Pleroma.Config.get(:instance)
	Pleroma.Config.put([:instance, :managed_config], true)
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], true)
	Pleroma.Config.put([:instance, :public], false)
	Pleroma.Config.put([:frontend_configurations, :pleroma_fe], %{theme: "asuka-hospital"})

	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/api/statusnet/config")
	\|> json_response(:ok)

	expected_data = %{
	"site" => %{
	"accountActivationRequired" => "0",
	"closed" => "1",
	"description" => Keyword.get(instance, :description),
	"invitesEnabled" => "1",
	"name" => Keyword.get(instance, :name),
	"pleromafe" => %{"theme" => "asuka-hospital"},
	"private" => "1",
	"safeDMMentionsEnabled" => "0",
	"server" => Pleroma.Web.base_url(),
	"textlimit" => to_string(Keyword.get(instance, :limit)),
	"uploadlimit" => %{
	"avatarlimit" => to_string(Keyword.get(instance, :avatar_upload_limit)),
	"backgroundlimit" => to_string(Keyword.get(instance, :background_upload_limit)),
	"bannerlimit" => to_string(Keyword.get(instance, :banner_upload_limit)),
	"uploadlimit" => to_string(Keyword.get(instance, :upload_limit))
	},
	"vapidPublicKey" => Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
	}
	}

	assert response == expected_data
	end

	test "returns the state of safe_dm_mentions flag", %{conn: conn} do
	Pleroma.Config.put([:instance, :safe_dm_mentions], true)

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["safeDMMentionsEnabled"] == "1"

	Pleroma.Config.put([:instance, :safe_dm_mentions], false)

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["safeDMMentionsEnabled"] == "0"
	end

	test "it returns the managed config", %{conn: conn} do
	Pleroma.Config.put([:instance, :managed_config], false)
	Pleroma.Config.put([:frontend_configurations, :pleroma_fe], %{theme: "asuka-hospital"})

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	refute response["site"]["pleromafe"]

	Pleroma.Config.put([:instance, :managed_config], true)

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["pleromafe"] == %{"theme" => "asuka-hospital"}
	end
	end

	describe "GET /api/pleroma/frontend_configurations" do
	test "returns everything in :pleroma, :frontend_configurations", %{conn: conn} do
	config = [
	frontend_a: %{
	x: 1,
	y: 2
	},
	frontend_b: %{
	z: 3
	}
	]

	Pleroma.Config.put(:frontend_configurations, config)

	response =
	conn
	\|> get("/api/pleroma/frontend_configurations")
	\|> json_response(:ok)

	assert response == Jason.encode!(config \|> Enum.into(%{})) \|> Jason.decode!()
	end
	end

	describe "/api/pleroma/emoji" do
	test "returns json with custom emoji with tags", %{conn: conn} do
	emoji =
	conn
	\|> get("/api/pleroma/emoji")
	\|> json_response(200)

	assert Enum.all?(emoji, fn
	{_key,
	%{
	"image_url" => url,
	"tags" => tags
	}} ->
	is_binary(url) and is_list(tags)
	end)
	end
	end

	describe "GET /api/pleroma/healthcheck" do
	clear_config([:instance, :healthcheck])

	test "returns 503 when healthcheck disabled", %{conn: conn} do
	Pleroma.Config.put([:instance, :healthcheck], false)

	response =
	conn
	\|> get("/api/pleroma/healthcheck")
	\|> json_response(503)

	assert response == %{}
	end

	test "returns 200 when healthcheck enabled and all ok", %{conn: conn} do
	Pleroma.Config.put([:instance, :healthcheck], true)

	with_mock Pleroma.Healthcheck,
	system_info: fn -> %Pleroma.Healthcheck{healthy: true} end do
	response =
	conn
	\|> get("/api/pleroma/healthcheck")
	\|> json_response(200)

	assert %{
	"active" => _,
	"healthy" => true,
	"idle" => _,
	"memory_used" => _,
	"pool_size" => _
	} = response
	end
	end

	test "returns 503 when healthcheck enabled and health is false", %{conn: conn} do
	Pleroma.Config.put([:instance, :healthcheck], true)

	with_mock Pleroma.Healthcheck,
	system_info: fn -> %Pleroma.Healthcheck{healthy: false} end do
	response =
	conn
	\|> get("/api/pleroma/healthcheck")
	\|> json_response(503)

	assert %{
	"active" => _,
	"healthy" => false,
	"idle" => _,
	"memory_used" => _,
	"pool_size" => _
	} = response
	end
	end
	end

	describe "POST /api/pleroma/disable_account" do
	setup do: oauth_access(["write:accounts"])

	test "with valid permissions and password, it disables the account", %{conn: conn, user: user} do
	response =
	conn
	\|> post("/api/pleroma/disable_account", %{"password" => "test"})
	\|> json_response(:ok)

	assert response == %{"status" => "success"}
	ObanHelpers.perform_all()

	user = User.get_cached_by_id(user.id)

	assert user.deactivated == true
	end

	test "with valid permissions and invalid password, it returns an error", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post("/api/pleroma/disable_account", %{"password" => "test1"})
	\|> json_response(:ok)

	assert response == %{"error" => "Invalid password."}
	user = User.get_cached_by_id(user.id)

	refute user.deactivated
	end
	end

	describe "GET /api/statusnet/version" do
	test "it returns version in xml format", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/api/statusnet/version")
	\|> response(:ok)

	assert response == "<version>#{Pleroma.Application.named_version()}</version>"
	end

	test "it returns version in json format", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/api/statusnet/version")
	\|> json_response(:ok)

	assert response == "#{Pleroma.Application.named_version()}"
	end
	end

	describe "POST /main/ostatus - remote_subscribe/2" do
	test "renders subscribe form", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post("/main/ostatus", %{"nickname" => user.nickname, "profile" => ""})
	\|> response(:ok)

	refute response =~ "Could not find user"
	assert response =~ "Remotely follow #{user.nickname}"
	end

	test "renders subscribe form with error when user not found", %{conn: conn} do
	response =
	conn
	\|> post("/main/ostatus", %{"nickname" => "nickname", "profile" => ""})
	\|> response(:ok)

	assert response =~ "Could not find user"
	refute response =~ "Remotely follow"
	end

	test "it redirect to webfinger url", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	conn =
	conn
	\|> post("/main/ostatus", %{
	"user" => %{"nickname" => user.nickname, "profile" => user2.ap_id}
	})

	assert redirected_to(conn) ==
	"https://social.heldscal.la/main/ostatussub?profile=#{user.ap_id}"
	end

	test "it renders form with error when user not found", %{conn: conn} do
	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	response =
	conn
	\|> post("/main/ostatus", %{"user" => %{"nickname" => "jimm", "profile" => user2.ap_id}})
	\|> response(:ok)

	assert response =~ "Something went wrong."
	end
	end

	test "it returns new captcha", %{conn: conn} do
	with_mock Pleroma.Captcha,
	new: fn -> "test_captcha" end do
	resp =
	conn
	\|> get("/api/pleroma/captcha")
	\|> response(200)

	assert resp == "\"test_captcha\""
	assert called(Pleroma.Captcha.new())
	end
	end

	describe "POST /api/pleroma/change_email" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> post("/api/pleroma/change_email")

	assert json_response(conn, 403) == %{"error" => "Insufficient permissions: write:accounts."}
	end

	test "with proper permissions and invalid password", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/change_email", %{
	"password" => "hi",
	"email" => "test@test.com"
	})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with proper permissions, valid password and invalid email", %{
	conn: conn
	} do
	conn =
	post(conn, "/api/pleroma/change_email", %{
	"password" => "test",
	"email" => "foobar"
	})

	assert json_response(conn, 200) == %{"error" => "Email has invalid format."}
	end

	test "with proper permissions, valid password and no email", %{
	conn: conn
	} do
	conn =
	post(conn, "/api/pleroma/change_email", %{
	"password" => "test"
	})

	assert json_response(conn, 200) == %{"error" => "Email can't be blank."}
	end

	test "with proper permissions, valid password and blank email", %{
	conn: conn
	} do
	conn =
	post(conn, "/api/pleroma/change_email", %{
	"password" => "test",
	"email" => ""
	})

	assert json_response(conn, 200) == %{"error" => "Email can't be blank."}
	end

	test "with proper permissions, valid password and non unique email", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	post(conn, "/api/pleroma/change_email", %{
	"password" => "test",
	"email" => user.email
	})

	assert json_response(conn, 200) == %{"error" => "Email has already been taken."}
	end

	test "with proper permissions, valid password and valid email", %{
	conn: conn
	} do
	conn =
	post(conn, "/api/pleroma/change_email", %{
	"password" => "test",
	"email" => "cofe@foobar.com"
	})

	assert json_response(conn, 200) == %{"status" => "success"}
	end
	end

	describe "POST /api/pleroma/change_password" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> post("/api/pleroma/change_password")

	assert json_response(conn, 403) == %{"error" => "Insufficient permissions: write:accounts."}
	end

	test "with proper permissions and invalid password", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with proper permissions, valid password and new password and confirmation not matching",
	%{
	conn: conn
	} do
	conn =
	post(conn, "/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "notnewpass"
	})

	assert json_response(conn, 200) == %{
	"error" => "New password does not match confirmation."
	}
	end

	test "with proper permissions, valid password and invalid new password", %{
	conn: conn
	} do
	conn =
	post(conn, "/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "",
	"new_password_confirmation" => ""
	})

	assert json_response(conn, 200) == %{
	"error" => "New password can't be blank."
	}
	end

	test "with proper permissions, valid password and matching new password and confirmation", %{
	conn: conn,
	user: user
	} do
	conn =
	post(conn, "/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"status" => "success"}
	fetched_user = User.get_cached_by_id(user.id)
	assert Comeonin.Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
	end
	end

	describe "POST /api/pleroma/delete_account" do
	setup do: oauth_access(["write:accounts"])

	test "without permissions", %{conn: conn} do
	conn =
	conn
	\|> assign(:token, nil)
	\|> post("/api/pleroma/delete_account")

	assert json_response(conn, 403) ==
	%{"error" => "Insufficient permissions: write:accounts."}
	end

	test "with proper permissions and wrong or missing password", %{conn: conn} do
	for params <- [%{"password" => "hi"}, %{}] do
	ret_conn = post(conn, "/api/pleroma/delete_account", params)

	assert json_response(ret_conn, 200) == %{"error" => "Invalid password."}
	end
	end

	test "with proper permissions and valid password", %{conn: conn} do
	conn = post(conn, "/api/pleroma/delete_account", %{"password" => "test"})

	assert json_response(conn, 200) == %{"status" => "success"}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 1:26 PM (15 h, 58 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1769514
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions