zio
/
bsky-app
2
0
Fork 0
Code Pull Requests Packages Releases Activity

Unit Testing (#35) 

* add testing lib

* remove coverage folder from git

* finished basic test setup

* fix tests typescript and import paths

* add first snapshot

* testing utils

* rename test files; update script flags; ++tests

* testing utils functions

* testing downloadAndResize wip

* remove download test

* specify unwanted coverage paths;
remove update snapshots flag

* fix strings tests

* testing downloadAndResize method

* increasing testing

* fixing snapshots wip

* fixed shell mobile snapshot

* adding snapshots for the screens

* fix onboard snapshot

* fix typescript issues

* fix TabsSelector snapshot

* Account for testing device's locale in ago() tests

* Remove platform detection on regex

* mocking store state wip

* mocking store state

* increasing test coverage

* increasing test coverage

* increasing test coverage on src/screens

* src/screens (except for profile) above 80% cov

* testing profile screen wip

* increase coverage on Menu and TabsSelector

* mocking profile ui state wip

* mocking profile ui state wip

* fixing mobileshell tests wip

* snapshots using testing-library

* fixing profile tests wip

* removing mobile shell tests

* src/view/com tests wip

* remove unnecessary patch-package

* fixed profile test error

* clear mocks after every test

* fix base mocked store values (getters)

* fix base mocked store values
(hasLoaded, nonReplyFeed)

* profile screen above 80% coverage

* testing custom hooks

* improving composer coverage

* fix tests after merge

* finishing composer coverage

* improving src/com/discover coverage

* improve src/view/com/login coverage
fix SuggestedFollows tests
adding some comments

* fix SuggestedFollows tests

* improve src/view/com/profile coverage
extra minor fixes

* improve src/view/com/notifications coverage

* update coverage ignore patterns

* rename errorMessageTryAgainButton
increase SuggestedFollows converage

* improve src/view/com/posts coverage

* improve src/view/com/onboard coverage

* update snapshot

* improve src/view/com/post coverage

* improve src/view/com/post-thread coverage
rename ErrorMessage tests
test Debug and Log components

* init testing state

* testing root-store

* updating comments

* small fixes

* removed extra console logs

* improve src/state/models coverage
refactor rootStore
rename some spies

* adding cleanup method after tests

* improve src/state/models coverage

* improve src/state/models coverage

* improve src/state/models coverage

* improve src/state/models coverage

* test setInterval in setupState

* Clean up tests and update Home screen state management

* Remove some tests we dont need

* Remove snapshot tests

* Remove any tests that dont demonstrate clear value

* Cleanup

Co-authored-by: Paul Frazee <pfrazee@gmail.com>
zio/stable
João Ferreiro 2023-01-17 16:06:00 +00:00 committed by GitHub
parent 11c861d2d3
commit 5abcc8e336
95 changed files with 2852 additions and 9936 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
__mocks__/@react-native-camera-roll/camera-roll.js
View File

@ -1,3 +1,9 @@
export default {
CameraRoll: jest.fn(),
export const CameraRoll = {
getPhotos: jest.fn().mockResolvedValue({
edges: [
{node: {image: {uri: 'path/to/image1.jpg'}}},
{node: {image: {uri: 'path/to/image2.jpg'}}},
{node: {image: {uri: 'path/to/image3.jpg'}}},
],
}),
}

12
__mocks__/react-native-image-crop-picker.js vendored
View File

@ -1,3 +1,9 @@
export default {
openPicker: jest.fn().mockImplementation(() => Promise.resolve(result)),
}
export const openPicker = jest
.fn()
.mockImplementation(() => Promise.resolve({uri: ''}))
export const openCamera = jest
.fn()
.mockImplementation(() => Promise.resolve({uri: ''}))
export const openCropper = jest
.fn()
.mockImplementation(() => Promise.resolve({uri: ''}))

934
__mocks__/state-mock.ts 100644
View File

@ -0,0 +1,934 @@
import {LogModel} from './../src/state/models/log'
import {LRUMap} from 'lru_map'
import {RootStoreModel} from './../src/state/models/root-store'
import {NavigationTabModel} from './../src/state/models/navigation'
import {SessionModel} from '../src/state/models/session'
import {NavigationModel} from '../src/state/models/navigation'
import {ShellUiModel} from '../src/state/models/shell-ui'
import {MeModel} from '../src/state/models/me'
import {OnboardModel} from '../src/state/models/onboard'
import {ProfilesViewModel} from '../src/state/models/profiles-view'
import {LinkMetasViewModel} from '../src/state/models/link-metas-view'
import {MembershipsViewModel} from '../src/state/models/memberships-view'
import {FeedModel} from '../src/state/models/feed-view'
import {NotificationsViewModel} from '../src/state/models/notifications-view'
import {ProfileViewModel} from '../src/state/models/profile-view'
import {MembersViewModel} from '../src/state/models/members-view'
import {ProfileUiModel, Sections} from '../src/state/models/profile-ui'
import {SessionServiceClient} from '@atproto/api'
import {UserAutocompleteViewModel} from '../src/state/models/user-autocomplete-view'
import {UserLocalPhotosModel} from '../src/state/models/user-local-photos'
import {SuggestedActorsViewModel} from '../src/state/models/suggested-actors-view'
import {UserFollowersViewModel} from '../src/state/models/user-followers-view'
import {UserFollowsViewModel} from '../src/state/models/user-follows-view'
import {NotificationsViewItemModel} from './../src/state/models/notifications-view'
import {
PostThreadViewModel,
PostThreadViewPostModel,
} from '../src/state/models/post-thread-view'
import {FeedItemModel} from '../src/state/models/feed-view'
import {RepostedByViewModel} from '../src/state/models/reposted-by-view'
import {VotesViewModel} from '../src/state/models/votes-view'
export const mockedProfileStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: true,
error: '',
params: {
actor: '',
},
did: 'test did',
handle: 'testhandle',
declaration: {
cid: '',
actorType: '',
},
creator: 'test did',
displayName: '',
description: '',
avatar: '',
banner: '',
followersCount: 0,
followsCount: 0,
membersCount: 0,
postsCount: 0,
myState: {
follow: '',
member: '',
},
rootStore: {} as RootStoreModel,
hasContent: true,
hasError: false,
isEmpty: false,
isUser: true,
isScene: false,
setup: jest.fn().mockResolvedValue({aborted: false}),
refresh: jest.fn(),
toggleFollowing: jest.fn().mockResolvedValue({}),
updateProfile: jest.fn(),
// unknown required because of the missing private methods: _xLoading, _xIdle, _load, _replaceAll
} as unknown as ProfileViewModel
export const mockedMembersStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: true,
error: '',
params: {
actor: 'test actor',
},
subject: {
did: 'test did',
handle: '',
displayName: '',
declaration: {
cid: '',
actorType: '',
},
avatar: undefined,
},
members: [
{
did: 'test did2',
declaration: {
cid: '',
actorType: '',
},
handle: 'testhandle',
displayName: 'test name',
indexedAt: '',
},
],
rootStore: {} as RootStoreModel,
hasContent: true,
hasError: false,
isEmpty: false,
isMember: jest.fn(),
setup: jest.fn().mockResolvedValue({aborted: false}),
refresh: jest.fn(),
loadMore: jest.fn(),
removeMember: jest.fn(),
// unknown required because of the missing private methods: _xLoading, _xIdle, _fetch, _replaceAll, _append
} as unknown as MembersViewModel
export const mockedMembershipsStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: true,
error: '',
params: {
actor: '',
limit: 1,
before: '',
},
subject: {
did: 'test did',
handle: '',
displayName: '',
declaration: {cid: '', actorType: ''},
avatar: undefined,
},
memberships: [
{
did: 'test did',
declaration: {
cid: '',
actorType: 'app.bsky.system.actorUser',
},
handle: ',',
displayName: '',
createdAt: '',
indexedAt: '',
_reactKey: 'item-1',
},
],
rootStore: {} as RootStoreModel,
hasContent: true,
hasError: false,
isEmpty: false,
isMemberOf: jest.fn(),
setup: jest.fn().mockResolvedValue({aborted: false}),
refresh: jest.fn(),
loadMore: jest.fn(),
// unknown required because of the missing private methods: _xLoading, _xIdle, _fetch, _replaceAll, _append
} as unknown as MembershipsViewModel
export const mockedFeedItemStore = {
_reactKey: 'item-1',
_isThreadParent: false,
_isThreadChildElided: false,
_isThreadChild: false,
post: {
uri: 'testuri',
cid: 'test cid',
author: {
did: 'test did',
handle: 'test.handle',
displayName: 'test name',
declaration: {cid: '', actorType: ''},
},
record: {
$type: 'app.bsky.feed.post',
createdAt: '2022-12-29T16:39:57.919Z',
text: 'Sup',
},
replyCount: 0,
repostCount: 0,
upvoteCount: 0,
downvoteCount: 0,
indexedAt: '2022-12-29T16:39:57.919Z',
viewer: {},
},
postRecord: {
$type: 'app.bsky.feed.post',
text: 'test text',
createdAt: '1',
reply: {
root: {
uri: 'testuri',
cid: 'tes cid',
},
parent: {
uri: 'testuri',
cid: 'tes cid',
},
},
},
rootStore: {} as RootStoreModel,
copy: jest.fn(),
toggleUpvote: jest.fn().mockResolvedValue({}),
toggleDownvote: jest.fn(),
toggleRepost: jest.fn().mockResolvedValue({}),
delete: jest.fn().mockResolvedValue({}),
reasonRepost: {
by: {
did: 'test did',
handle: 'test.handle',
declaration: {cid: '', actorType: ''},
},
indexedAt: '',
},
reasonTrend: {
by: {
did: 'test did',
handle: 'test.handle',
declaration: {cid: '', actorType: ''},
},
indexedAt: '',
},
reply: {
parent: {
author: {
did: 'test did',
handle: 'test.handle',
displayName: 'test name',
declaration: {cid: '', actorType: ''},
},
cid: '',
downvoteCount: 0,
indexedAt: '2023-01-10T11:17:46.945Z',
record: {},
replyCount: 1,
repostCount: 0,
upvoteCount: 0,
uri: 'testuri',
viewer: {},
},
root: {
author: {
did: 'test did',
handle: 'test.handle',
displayName: 'test name',
declaration: {cid: '', actorType: ''},
},
cid: '',
downvoteCount: 0,
indexedAt: '2023-01-10T11:17:46.739Z',
record: {},
replyCount: 1,
repostCount: 0,
upvoteCount: 1,
uri: 'testuri',
viewer: {},
},
},
} as FeedItemModel
export const mockedFeedStore = {
isLoading: false,
isRefreshing: false,
hasNewLatest: false,
hasLoaded: true,
error: '',
hasMore: true,
params: {
actor: '',
limit: 1,
before: '',
},
feed: [],
rootStore: {} as RootStoreModel,
feedType: 'home',
hasContent: true,
hasError: false,
isEmpty: false,
nonReplyFeed: [
{
_reactKey: 'item-1',
post: {
author: {
handle: 'handle.test',
displayName: 'test name',
avatar: '',
},
cid: 'bafyreihkwjoy2vbfqld2lp3tv4ce6yfr354sqgp32qoplrudso4gyyjiwe',
downvoteCount: 0,
indexedAt: '2022-12-29T16:35:55.270Z',
record: {
$type: 'app.bsky.feed.post',
createdAt: '2022-12-29T16:39:57.919Z',
text: 'Sup',
},
replyCount: 0,
repostCount: 0,
upvoteCount: 0,
uri: 'at://did:plc:wcizmlgv3rdslk64t6q4silu/app.bsky.feed.post/3jkzce5kfvn2h',
viewer: {
handle: 'handle.test',
displayName: 'test name',
avatar: '',
},
},
reason: undefined,
reply: undefined,
},
],
setHasNewLatest: jest.fn(),
setup: jest.fn().mockResolvedValue({}),
refresh: jest.fn().mockResolvedValue({}),
loadMore: jest.fn().mockResolvedValue({}),
loadLatest: jest.fn(),
update: jest.fn(),
checkForLatest: jest.fn().mockRejectedValue('Error checking for latest'),
// unknown required because of the missing private methods: _xLoading, _xIdle, _pendingWork, _initialLoad, _loadLatest, _loadMore, _update, _replaceAll, _appendAll, _prependAll, _updateAll, _getFeed, loadMoreCursor, pollCursor, _loadPromise, _updatePromise, _loadLatestPromise, _loadMorePromise
} as unknown as FeedModel
export const mockedPostThreadViewPostStore = {
_reactKey: 'item-1',
_depth: 0,
_isHighlightedPost: false,
_hasMore: false,
postRecord: {
text: 'test text',
createdAt: '',
reply: {
root: {
uri: 'testuri',
cid: 'tes cid',
},
parent: {
uri: 'testuri',
cid: 'tes cid',
},
},
},
post: {
uri: 'testuri',
cid: 'testcid',
record: {},
author: {
did: 'test did',
handle: 'test.handle',
declaration: {cid: '', actorType: ''},
viewer: {
muted: true,
},
},
replyCount: 0,
repostCount: 0,
upvoteCount: 0,
downvoteCount: 0,
indexedAt: '',
viewer: {
repost: '',
upvote: '',
downvote: '',
},
},
rootStore: {} as RootStoreModel,
assignTreeModels: jest.fn(),
toggleRepost: jest.fn().mockRejectedValue({}),
toggleUpvote: jest.fn().mockRejectedValue({}),
toggleDownvote: jest.fn(),
delete: jest.fn(),
} as PostThreadViewPostModel
export const mockedPostThreadViewStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: false,
error: '',
notFound: false,
resolvedUri: 'testuri',
params: {
uri: 'testuri',
},
thread: mockedPostThreadViewPostStore,
hasContent: true,
hasError: false,
setup: jest.fn(),
refresh: jest.fn().mockResolvedValue({}),
update: jest.fn(),
// unknown required because of the missing private methods: _xLoading, _xIdle, _resolveUri, _load, _replaceAll
} as unknown as PostThreadViewModel
export const mockedNotificationsViewItemStore = {
_reactKey: 'item-1',
uri: 'testuri',
cid: '',
author: {
did: 'test did',
handle: 'test.handle',
declaration: {cid: '', actorType: ''},
},
rootStore: {} as RootStoreModel,
copy: jest.fn(),
reason: 'test reason',
isRead: true,
indexedAt: '',
isUpvote: true,
isRepost: false,
isTrend: false,
isMention: false,
isReply: false,
isFollow: false,
isAssertion: false,
needsAdditionalData: false,
isInvite: false,
subjectUri: 'testuri',
toSupportedRecord: jest.fn().mockReturnValue({
text: 'test text',
createdAt: '',
}),
fetchAdditionalData: jest.fn(),
} as NotificationsViewItemModel
export const mockedNotificationsStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: true,
error: '',
params: {
limit: 1,
before: '',
},
hasMore: true,
notifications: [mockedNotificationsViewItemStore],
rootStore: {} as RootStoreModel,
hasContent: true,
hasError: false,
isEmpty: false,
setup: jest.fn().mockResolvedValue({aborted: false}),
refresh: jest.fn().mockResolvedValue({}),
loadMore: jest.fn().mockResolvedValue({}),
update: jest.fn().mockResolvedValue(null),
updateReadState: jest.fn(),
// unknown required because of the missing private methods: _xLoading, _xIdle, _pendingWork, _initialLoad, _loadMore, _update, _replaceAll, _appendAll, _updateAll, loadMoreCursor, _loadPromise, _updatePromise, _loadLatestPromise, _loadMorePromise
} as unknown as NotificationsViewModel
export const mockedSessionStore = {
serialize: jest.fn(),
hydrate: jest.fn(),
data: {
service: '',
refreshJwt: '',
accessJwt: '',
handle: '',
did: 'test did',
},
online: false,
attemptingConnect: false,
rootStore: {} as RootStoreModel,
hasSession: true,
clear: jest.fn(),
setState: jest.fn(),
setOnline: jest.fn(),
updateAuthTokens: jest.fn(),
connect: jest.fn(),
describeService: jest.fn().mockResolvedValue({
availableUserDomains: ['test'],
links: {
termsOfService: 'https://testTermsOfService',
privacyPolicy: 'https://testPrivacyPolicy',
},
}),
login: jest.fn(),
createAccount: jest.fn(),
logout: jest.fn(),
// unknown required because of the missing private methods: _connectPromise, configureApi & _connect
} as unknown as SessionModel
export const mockedNavigationTabStore = {
serialize: jest.fn(),
hydrate: jest.fn(),
id: 0,
history: [
{
url: '',
ts: 0,
title: '',
id: 0,
},
],
index: 0,
isNewTab: false,
current: {
url: '',
ts: 0,
title: '',
id: 0,
},
canGoBack: false,
canGoForward: false,
backTen: [
{
url: '',
title: '',
index: 0,
id: 0,
},
],
forwardTen: [
{
url: '',
title: '',
index: 0,
id: 0,
},
],
navigate: jest.fn(),
refresh: jest.fn(),
goBack: jest.fn(),
fixedTabReset: jest.fn(),
goForward: jest.fn(),
goToIndex: jest.fn(),
setTitle: jest.fn(),
setIsNewTab: jest.fn(),
fixedTabPurpose: 0,
getBackList: () => [
{
url: '/',
title: '',
index: 1,
id: 1,
},
],
getForwardList: jest.fn(),
} as NavigationTabModel
export const mockedNavigationStore = {
serialize: jest.fn(),
hydrate: jest.fn(),
tabs: [mockedNavigationTabStore],
tabIndex: 0,
clear: jest.fn(),
tab: mockedNavigationTabStore,
tabCount: 1,
isCurrentScreen: jest.fn(),
navigate: jest.fn(),
refresh: jest.fn(),
setTitle: jest.fn(),
handleLink: jest.fn(),
switchTo: jest.fn(),
setActiveTab: jest.fn(),
closeTab: jest.fn(),
newTab: jest.fn(),
} as NavigationModel
export const mockedShellStore = {
serialize: jest.fn(),
hydrate: jest.fn(),
minimalShellMode: false,
isMainMenuOpen: false,
isModalActive: false,
activeModal: undefined,
isLightboxActive: false,
activeLightbox: undefined,
isComposerActive: false,
composerOpts: undefined,
darkMode: false,
setDarkMode: jest.fn(),
setMainMenuOpen: jest.fn(),
setMinimalShellMode: jest.fn(),
openModal: jest.fn(),
closeModal: jest.fn(),
closeComposer: jest.fn(),
closeLightbox: jest.fn(),
openComposer: jest.fn(),
openLightbox: jest.fn(),
} as ShellUiModel
export const mockedMeStore = {
serialize: jest.fn(),
hydrate: jest.fn(),
did: 'test did',
handle: 'test',
displayName: 'test',
description: 'test',
avatar: '',
notificationCount: 0,
rootStore: {} as RootStoreModel,
memberships: mockedMembershipsStore,
mainFeed: mockedFeedStore,
notifications: mockedNotificationsStore,
clear: jest.fn(),
load: jest.fn(),
clearNotificationCount: jest.fn(),
fetchStateUpdate: jest.fn(),
refreshMemberships: jest.fn(),
} as MeModel
export const mockedOnboardStore = {
serialize: jest.fn(),
hydrate: jest.fn(),
isOnboarding: false,
stage: '',
start: jest.fn(),
stop: jest.fn(),
next: jest.fn(),
} as OnboardModel
export const mockedProfilesStore = {
hydrate: jest.fn(),
serialize: jest.fn(),
cache: new LRUMap(100),
rootStore: {} as RootStoreModel,
getProfile: jest.fn().mockResolvedValue({data: {}}),
overwrite: jest.fn(),
} as ProfilesViewModel
export const mockedLinkMetasStore = {
hydrate: jest.fn(),
serialize: jest.fn(),
cache: new LRUMap(100),
rootStore: {} as RootStoreModel,
getLinkMeta: jest.fn(),
} as LinkMetasViewModel
export const mockedLogStore = {
entries: [],
serialize: jest.fn(),
hydrate: jest.fn(),
debug: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
// unknown required because of the missing private methods: add
} as unknown as LogModel
export const mockedRootStore = {
api: {
com: {},
app: {
bsky: {
graph: {
confirmation: {
delete: jest.fn().mockResolvedValue({}),
},
getFollowers: jest.fn().mockResolvedValue({}),
getMembers: jest.fn().mockResolvedValue({}),
},
},
},
} as unknown as SessionServiceClient,
resolveName: jest.fn(),
serialize: jest.fn(),
hydrate: jest.fn(),
fetchStateUpdate: jest.fn(),
clearAll: jest.fn(),
session: mockedSessionStore,
nav: mockedNavigationStore,
shell: mockedShellStore,
me: mockedMeStore,
onboard: mockedOnboardStore,
profiles: mockedProfilesStore,
linkMetas: mockedLinkMetasStore,
log: mockedLogStore,
} as RootStoreModel
export const mockedProfileUiStore = {
profile: mockedProfileStore,
feed: mockedFeedStore,
memberships: mockedMembershipsStore,
members: mockedMembersStore,
selectedViewIndex: 0,
rootStore: mockedRootStore,
params: {
user: 'test user',
},
currentView: mockedFeedStore,
isInitialLoading: false,
isRefreshing: false,
isUser: true,
isScene: false,
selectorItems: [Sections.Posts, Sections.PostsWithReplies, Sections.Scenes],
selectedView: Sections.Posts,
setSelectedViewIndex: jest.fn(),
setup: jest.fn().mockResolvedValue({aborted: false}),
update: jest.fn(),
refresh: jest.fn(),
loadMore: jest.fn(),
} as ProfileUiModel
export const mockedAutocompleteViewStore = {
isLoading: false,
isActive: true,
prefix: '',
follows: [
{
did: 'test did',
declaration: {
cid: '',
actorType: 'app.bsky.system.actorUser',
},
handle: '',
displayName: '',
createdAt: '',
indexedAt: '',
},
],
searchRes: [
{
did: 'test did',
declaration: {
cid: '',
actorType: 'app.bsky.system.actorUser',
},
handle: '',
displayName: '',
},
],
knownHandles: new Set<string>(),
suggestions: [
{
handle: 'handle.test',
displayName: 'Test Display',
},
{
handle: 'handle2.test',
displayName: 'Test Display 2',
},
],
rootStore: {} as RootStoreModel,
setup: jest.fn(),
setActive: jest.fn(),
setPrefix: jest.fn(),
// unknown required because of the missing private methods: _searchPromise, _getFollows , _search
} as unknown as UserAutocompleteViewModel
export const mockedLocalPhotosStore = {
photos: {
node: {
type: '',
group_name: '',
image: {
filename: '',
extension: '',
uri: '',
height: 1000,
width: 1000,
fileSize: null,
playableDuration: 0,
},
timestamp: 1672847197,
location: null,
},
},
rootStore: {} as RootStoreModel,
setup: jest.fn(),
// unknown required because of the missing private methods: _getPhotos
} as unknown as UserLocalPhotosModel
export const mockedSuggestedActorsStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: false,
error: '',
suggestions: [
{
did: '1',
declaration: {
cid: '',
actorType: 'app.bsky.system.actorUser',
},
handle: 'handle1.test',
displayName: 'test name 1',
description: 'desc',
indexedAt: '',
_reactKey: '1',
},
{
did: '2',
declaration: {
cid: '',
actorType: 'app.bsky.system.actorUser',
},
handle: '',
displayName: 'handle2.test',
description: 'desc',
indexedAt: '',
_reactKey: '2',
},
],
rootStore: {} as RootStoreModel,
hasContent: true,
hasError: false,
isEmpty: false,
setup: jest.fn().mockResolvedValue(null),
refresh: jest.fn(),
// unknown required because of the missing private methods: _xLoading, _xIdle, _fetch, _appendAll, _append
} as unknown as SuggestedActorsViewModel
export const mockedUserFollowersStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: false,
error: '',
params: {
user: 'test user',
},
subject: {
did: 'test did',
handle: '',
declaration: {cid: '', actorType: ''},
},
followers: [
{
did: 'test did',
declaration: {cid: '', actorType: ''},
handle: 'testhandle',
displayName: 'test name',
indexedAt: '',
_reactKey: '1',
},
{
did: 'test did2',
declaration: {cid: '', actorType: ''},
handle: 'testhandle2',
displayName: 'test name 2',
indexedAt: '',
_reactKey: '2',
},
],
rootStore: {} as RootStoreModel,
hasContent: true,
hasError: false,
isEmpty: false,
setup: jest.fn(),
refresh: jest.fn(),
loadMore: jest.fn(),
// unknown required because of the missing private methods: _xIdle, _xLoading, _fetch, _replaceAll, _append
} as unknown as UserFollowersViewModel
export const mockedUserFollowsStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: false,
error: '',
params: {
user: 'test user',
},
subject: {
did: 'test did',
handle: '',
declaration: {cid: '', actorType: ''},
},
follows: [
{
did: 'test did',
declaration: {cid: '', actorType: ''},
handle: 'testhandle',
displayName: 'test name',
indexedAt: '',
_reactKey: '1',
},
{
did: 'test did2',
declaration: {cid: '', actorType: ''},
handle: 'testhandle2',
displayName: 'test name 2',
indexedAt: '',
_reactKey: '2',
},
],
rootStore: {} as RootStoreModel,
hasContent: true,
hasError: false,
isEmpty: false,
setup: jest.fn(),
refresh: jest.fn(),
loadMore: jest.fn(),
// unknown required because of the missing private methods: _xIdle, _xLoading, _fetch, _replaceAll, _append
} as unknown as UserFollowsViewModel
export const mockedRepostedByViewStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: false,
error: '',
resolvedUri: '',
params: {
uri: 'testuri',
},
uri: '',
repostedBy: [
{
_reactKey: '',
did: '',
handle: '',
displayName: '',
declaration: {cid: '', actorType: ''},
indexedAt: '',
},
],
hasContent: false,
hasError: false,
isEmpty: false,
setup: jest.fn().mockResolvedValue({}),
refresh: jest.fn().mockResolvedValue({}),
loadMore: jest.fn().mockResolvedValue({}),
// unknown required because of the missing private methods: _xIdle, _xLoading, _resolveUri, _fetch, _refresh, _replaceAll, _append
} as unknown as RepostedByViewModel
export const mockedVotesViewStore = {
isLoading: false,
isRefreshing: false,
hasLoaded: false,
error: '',
resolvedUri: '',
params: {
uri: 'testuri',
},
uri: '',
votes: [
{
_reactKey: '',
direction: 'up',
indexedAt: '',
createdAt: '',
actor: {
did: '',
handle: '',
declaration: {cid: '', actorType: ''},
},
},
],
hasContent: false,
hasError: false,
isEmpty: false,
setup: jest.fn(),
refresh: jest.fn().mockResolvedValue({}),
loadMore: jest.fn().mockResolvedValue({}),
// unknown required because of the missing private methods: _xIdle, _xLoading, _resolveUri, _fetch, _replaceAll, _append
} as unknown as VotesViewModel

18
__tests__/lib/images.test.ts
View File

@ -2,31 +2,27 @@ import {downloadAndResize, DownloadAndResizeOpts} from '../../src/lib/images'
import ImageResizer from '@bam.tech/react-native-image-resizer'
import RNFetchBlob from 'rn-fetch-blob'
jest.mock('rn-fetch-blob', () => ({
config: jest.fn().mockReturnThis(),
cancel: jest.fn(),
fetch: jest.fn(),
}))
jest.mock('@bam.tech/react-native-image-resizer', () => ({
createResizedImage: jest.fn(),
}))
describe('downloadAndResize', () => {
const errorSpy = jest.spyOn(global.console, 'error')
const mockResizedImage = {
path: jest.fn().mockReturnValue('file://resized-image.jpg'),
size: 100,
width: 50,
height: 50,
mime: 'image/jpeg',
}
beforeEach(() => {
jest.clearAllMocks()
const mockedCreateResizedImage =
ImageResizer.createResizedImage as jest.Mock
mockedCreateResizedImage.mockResolvedValue(mockResizedImage)
})
afterEach(() => {
jest.clearAllMocks()
})
it('should return resized image for valid URI and options', async () => {
const mockedFetch = RNFetchBlob.fetch as jest.Mock
mockedFetch.mockResolvedValueOnce({

72
__tests__/state/models/link-metas-view.test.ts 100644
View File

@ -0,0 +1,72 @@
import {RootStoreModel} from '../../../src/state/models/root-store'
import {LinkMetasViewModel} from '../../../src/state/models/link-metas-view'
import * as LinkMetaLib from '../../../src/lib/link-meta'
import {LikelyType} from './../../../src/lib/link-meta'
import {sessionClient, SessionServiceClient} from '@atproto/api'
import {DEFAULT_SERVICE} from '../../../src/state'
describe('LinkMetasViewModel', () => {
let viewModel: LinkMetasViewModel
let rootStore: RootStoreModel
const getLinkMetaMockSpy = jest.spyOn(LinkMetaLib, 'getLinkMeta')
const mockedMeta = {
title: 'Test Title',
url: 'testurl',
likelyType: LikelyType.Other,
}
beforeEach(() => {
const api = sessionClient.service(DEFAULT_SERVICE) as SessionServiceClient
rootStore = new RootStoreModel(api)
viewModel = new LinkMetasViewModel(rootStore)
})
afterAll(() => {
jest.clearAllMocks()
})
describe('getLinkMeta', () => {
it('should return link meta if it is cached', async () => {
const url = 'http://example.com'
viewModel.cache.set(url, mockedMeta)
const result = await viewModel.getLinkMeta(url)
expect(getLinkMetaMockSpy).not.toHaveBeenCalled()
expect(result).toEqual(mockedMeta)
})
it('should return link meta if it is not cached', async () => {
getLinkMetaMockSpy.mockResolvedValueOnce(mockedMeta)
const result = await viewModel.getLinkMeta(mockedMeta.url)
expect(getLinkMetaMockSpy).toHaveBeenCalledWith(mockedMeta.url)
expect(result).toEqual(mockedMeta)
})
it('should cache the link meta if it is successfully returned', async () => {
getLinkMetaMockSpy.mockResolvedValueOnce(mockedMeta)
await viewModel.getLinkMeta(mockedMeta.url)
expect(viewModel.cache.get(mockedMeta.url)).toEqual(mockedMeta)
})
it('should not cache the link meta if it fails to return', async () => {
const url = 'http://example.com'
const error = new Error('Failed to fetch link meta')
getLinkMetaMockSpy.mockRejectedValueOnce(error)
try {
await viewModel.getLinkMeta(url)
fail('Error was not thrown')
} catch (e) {
expect(e).toEqual(error)
expect(viewModel.cache.get(url)).toBeUndefined()
}
})
})
})

153
__tests__/state/models/log.test.ts 100644
View File

@ -0,0 +1,153 @@
import {LogModel} from '../../../src/state/models/log'
describe('LogModel', () => {
let logModel: LogModel
beforeEach(() => {
logModel = new LogModel()
jest.spyOn(console, 'debug')
})
afterAll(() => {
jest.clearAllMocks()
})
it('should call a log method and add a log entry to the entries array', () => {
logModel.debug('Test log')
expect(logModel.entries.length).toEqual(1)
expect(logModel.entries[0]).toEqual({
id: logModel.entries[0].id,
type: 'debug',
summary: 'Test log',
details: undefined,
ts: logModel.entries[0].ts,
})
logModel.warn('Test log')
expect(logModel.entries.length).toEqual(2)
expect(logModel.entries[1]).toEqual({
id: logModel.entries[1].id,
type: 'warn',
summary: 'Test log',
details: undefined,
ts: logModel.entries[1].ts,
})
logModel.error('Test log')
expect(logModel.entries.length).toEqual(3)
expect(logModel.entries[2]).toEqual({
id: logModel.entries[2].id,
type: 'error',
summary: 'Test log',
details: undefined,
ts: logModel.entries[2].ts,
})
})
it('should call the console.debug after calling the debug method', () => {
logModel.debug('Test log')
expect(console.debug).toHaveBeenCalledWith('Test log', '')
})
it('should call the serialize method', () => {
logModel.debug('Test log')
expect(logModel.serialize()).toEqual({
entries: [
{
id: logModel.entries[0].id,
type: 'debug',
summary: 'Test log',
details: undefined,
ts: logModel.entries[0].ts,
},
],
})
})
it('should call the hydrate method with valid properties', () => {
logModel.hydrate({
entries: [
{
id: '123',
type: 'debug',
summary: 'Test log',
details: undefined,
ts: 123,
},
],
})
expect(logModel.entries).toEqual([
{
id: '123',
type: 'debug',
summary: 'Test log',
details: undefined,
ts: 123,
},
])
})
it('should call the hydrate method with invalid properties', () => {
logModel.hydrate({
entries: [
{
id: '123',
type: 'debug',
summary: 'Test log',
details: undefined,
ts: 123,
},
{
summary: 'Invalid entry',
},
],
})
expect(logModel.entries).toEqual([
{
id: '123',
type: 'debug',
summary: 'Test log',
details: undefined,
ts: 123,
},
])
})
it('should stringify the details if it is not a string', () => {
logModel.debug('Test log', {details: 'test'})
expect(logModel.entries[0].details).toEqual('{\n "details": "test"\n}')
})
it('should stringify the details object if it is of a specific error', () => {
class TestError extends Error {
constructor() {
super()
this.name = 'TestError'
}
}
const error = new TestError()
logModel.error('Test error log', error)
expect(logModel.entries[0].details).toEqual('TestError')
class XRPCInvalidResponseErrorMock {
validationError = {toString: () => 'validationError'}
lexiconNsid = 'test'
}
const xrpcInvalidResponseError = new XRPCInvalidResponseErrorMock()
logModel.error('Test error log', xrpcInvalidResponseError)
expect(logModel.entries[1].details).toEqual(
'{\n "validationError": {},\n "lexiconNsid": "test"\n}',
)
class XRPCErrorMock {
status = 'status'
error = 'error'
message = 'message'
}
const xrpcError = new XRPCErrorMock()
logModel.error('Test error log', xrpcError)
expect(logModel.entries[2].details).toEqual(
'{\n "status": "status",\n "error": "error",\n "message": "message"\n}',
)
})
})

183
__tests__/state/models/me.test.ts 100644
View File

@ -0,0 +1,183 @@
import {RootStoreModel} from '../../../src/state/models/root-store'
import {MeModel} from '../../../src/state/models/me'
import {MembershipsViewModel} from './../../../src/state/models/memberships-view'
import {NotificationsViewModel} from './../../../src/state/models/notifications-view'
import {sessionClient, SessionServiceClient} from '@atproto/api'
import {DEFAULT_SERVICE} from './../../../src/state/index'
describe('MeModel', () => {
let rootStore: RootStoreModel
let meModel: MeModel
beforeEach(() => {
const api = sessionClient.service(DEFAULT_SERVICE) as SessionServiceClient
rootStore = new RootStoreModel(api)
meModel = new MeModel(rootStore)
})
afterAll(() => {
jest.clearAllMocks()
})
it('should clear() correctly', () => {
meModel.did = '123'
meModel.handle = 'handle'
meModel.displayName = 'John Doe'
meModel.description = 'description'
meModel.avatar = 'avatar'
meModel.notificationCount = 1
meModel.clear()
expect(meModel.did).toEqual('')
expect(meModel.handle).toEqual('')
expect(meModel.displayName).toEqual('')
expect(meModel.description).toEqual('')
expect(meModel.avatar).toEqual('')
expect(meModel.notificationCount).toEqual(0)
expect(meModel.memberships).toBeUndefined()
})
it('should hydrate() successfully with valid properties', () => {
meModel.hydrate({
did: '123',
handle: 'handle',
displayName: 'John Doe',
description: 'description',
avatar: 'avatar',
})
expect(meModel.did).toEqual('123')
expect(meModel.handle).toEqual('handle')
expect(meModel.displayName).toEqual('John Doe')
expect(meModel.description).toEqual('description')
expect(meModel.avatar).toEqual('avatar')
})
it('should not hydrate() with invalid properties', () => {
meModel.hydrate({
did: '',
handle: 'handle',
displayName: 'John Doe',
description: 'description',
avatar: 'avatar',
})
expect(meModel.did).toEqual('')
expect(meModel.handle).toEqual('')
expect(meModel.displayName).toEqual('')
expect(meModel.description).toEqual('')
expect(meModel.avatar).toEqual('')
meModel.hydrate({
did: '123',
displayName: 'John Doe',
description: 'description',
avatar: 'avatar',
})
expect(meModel.did).toEqual('')
expect(meModel.handle).toEqual('')
expect(meModel.displayName).toEqual('')
expect(meModel.description).toEqual('')
expect(meModel.avatar).toEqual('')
})
it('should load() successfully', async () => {
jest
.spyOn(rootStore.api.app.bsky.actor, 'getProfile')
.mockImplementationOnce((): Promise<any> => {
return Promise.resolve({
data: {
displayName: 'John Doe',
description: 'description',
avatar: 'avatar',
},
})
})
rootStore.session.data = {
did: '123',
handle: 'handle',
service: 'test service',
accessJwt: 'test token',
refreshJwt: 'test token',
}
await meModel.load()
expect(meModel.did).toEqual('123')
expect(meModel.handle).toEqual('handle')
expect(meModel.displayName).toEqual('John Doe')
expect(meModel.description).toEqual('description')
expect(meModel.avatar).toEqual('avatar')
})
it('should load() successfully without profile data', async () => {
jest
.spyOn(rootStore.api.app.bsky.actor, 'getProfile')
.mockImplementationOnce((): Promise<any> => {
return Promise.resolve({
data: null,
})
})
rootStore.session.data = {
did: '123',
handle: 'handle',
service: 'test service',
accessJwt: 'test token',
refreshJwt: 'test token',
}
await meModel.load()
expect(meModel.did).toEqual('123')
expect(meModel.handle).toEqual('handle')
expect(meModel.displayName).toEqual('')
expect(meModel.description).toEqual('')
expect(meModel.avatar).toEqual('')
})
it('should load() to nothing when no session', async () => {
rootStore.session.data = null
await meModel.load()
expect(meModel.did).toEqual('')
expect(meModel.handle).toEqual('')
expect(meModel.displayName).toEqual('')
expect(meModel.description).toEqual('')
expect(meModel.avatar).toEqual('')
expect(meModel.notificationCount).toEqual(0)
expect(meModel.memberships).toBeUndefined()
})
it('should serialize() key information', () => {
meModel.did = '123'
meModel.handle = 'handle'
meModel.displayName = 'John Doe'
meModel.description = 'description'
meModel.avatar = 'avatar'
expect(meModel.serialize()).toEqual({
did: '123',
handle: 'handle',
displayName: 'John Doe',
description: 'description',
avatar: 'avatar',
})
})
it('should clearNotificationCount() successfully', () => {
meModel.clearNotificationCount()
expect(meModel.notificationCount).toBe(0)
})
it('should update notifs count with fetchStateUpdate()', async () => {
meModel.notifications = {
refresh: jest.fn(),
} as unknown as NotificationsViewModel
jest
.spyOn(rootStore.api.app.bsky.notification, 'getCount')
.mockImplementationOnce((): Promise<any> => {
return Promise.resolve({
data: {
count: 1,
},
})
})
await meModel.fetchStateUpdate()
expect(meModel.notificationCount).toBe(1)
expect(meModel.notifications.refresh).toHaveBeenCalled()
})
})

154
__tests__/state/models/navigation.test.ts 100644
View File

@ -0,0 +1,154 @@
import {
NavigationModel,
NavigationTabModel,
} from './../../../src/state/models/navigation'
import * as flags from '../../../src/build-flags'
describe('NavigationModel', () => {
let model: NavigationModel
beforeEach(() => {
model = new NavigationModel()
model.setTitle([0, 0], 'title')
})
afterAll(() => {
jest.clearAllMocks()
})
it('should clear() to the correct base state', async () => {
await model.clear()
expect(model.tabCount).toBe(2)
expect(model.tab).toEqual({
fixedTabPurpose: 0,
history: [
{
id: expect.anything(),
ts: expect.anything(),
url: '/',
},
],
id: expect.anything(),
index: 0,
isNewTab: false,
})
})
it('should call the navigate method', async () => {
const navigateSpy = jest.spyOn(model.tab, 'navigate')
await model.navigate('testurl', 'teststring')
expect(navigateSpy).toHaveBeenCalledWith('testurl', 'teststring')
})
it('should call the refresh method', async () => {
const refreshSpy = jest.spyOn(model.tab, 'refresh')
await model.refresh()
expect(refreshSpy).toHaveBeenCalled()
})
it('should call the isCurrentScreen method', () => {
expect(model.isCurrentScreen(11, 0)).toEqual(false)
})
it('should call the tab getter', () => {
expect(model.tab).toEqual({
fixedTabPurpose: 0,
history: [
{
id: expect.anything(),
ts: expect.anything(),
url: '/',
},
],
id: expect.anything(),
index: 0,
isNewTab: false,
})
})
it('should call the tabCount getter', () => {
expect(model.tabCount).toBe(2)
})
describe('tabs not enabled', () => {
jest.mock('../../../src/build-flags', () => ({
TABS_ENABLED: false,
}))
afterAll(() => {
jest.clearAllMocks()
})
it('should not create new tabs', () => {
// @ts-expect-error
flags.TABS_ENABLED = false
model.newTab('testurl')
expect(model.tab.isNewTab).toBe(false)
expect(model.tabIndex).toBe(0)
})
it('should not change the active tab', () => {
// @ts-expect-error
flags.TABS_ENABLED = false
model.setActiveTab(2)
expect(model.tabIndex).toBe(0)
})
it('should note close tabs', () => {
// @ts-expect-error
flags.TABS_ENABLED = false
model.closeTab(0)
expect(model.tabCount).toBe(2)
})
})
describe('tabs enabled', () => {
jest.mock('../../../src/build-flags', () => ({
TABS_ENABLED: true,
}))
afterAll(() => {
jest.clearAllMocks()
})
it('should create new tabs', () => {
// @ts-expect-error
flags.TABS_ENABLED = true
model.newTab('testurl', 'title')
expect(model.tab.isNewTab).toBe(true)
expect(model.tabIndex).toBe(2)
})
it('should change the current tab', () => {
// @ts-expect-error
flags.TABS_ENABLED = true
model.setActiveTab(0)
expect(model.tabIndex).toBe(0)
})
it('should close tabs', () => {
// @ts-expect-error
flags.TABS_ENABLED = true
model.closeTab(0)
expect(model.tabs).toEqual([
{
fixedTabPurpose: 1,
history: [
{
id: expect.anything(),
ts: expect.anything(),
url: '/notifications',
},
],
id: expect.anything(),
index: 0,
isNewTab: false,
},
])
expect(model.tabIndex).toBe(0)
})
})
})

46
__tests__/state/models/onboard.test.ts 100644
View File

@ -0,0 +1,46 @@
import {
OnboardModel,
OnboardStageOrder,
} from '../../../src/state/models/onboard'
describe('OnboardModel', () => {
let onboardModel: OnboardModel
beforeEach(() => {
onboardModel = new OnboardModel()
})
afterAll(() => {
jest.clearAllMocks()
})
it('should start/stop correctly', () => {
onboardModel.start()
expect(onboardModel.isOnboarding).toBe(true)
onboardModel.stop()
expect(onboardModel.isOnboarding).toBe(false)
})
it('should call the next method until it has no more stages', () => {
onboardModel.start()
onboardModel.next()
expect(onboardModel.stage).toBe(OnboardStageOrder[1])
onboardModel.next()
expect(onboardModel.isOnboarding).toBe(false)
expect(onboardModel.stage).toBe(OnboardStageOrder[0])
})
it('serialize and hydrate', () => {
const serialized = onboardModel.serialize()
const newModel = new OnboardModel()
newModel.hydrate(serialized)
expect(newModel).toEqual(onboardModel)
onboardModel.start()
onboardModel.next()
const serialized2 = onboardModel.serialize()
newModel.hydrate(serialized2)
expect(newModel).toEqual(onboardModel)
})
})

73
__tests__/state/models/root-store.test.ts 100644
View File

@ -0,0 +1,73 @@
import {RootStoreModel} from '../../../src/state/models/root-store'
import {setupState} from '../../../src/state'
describe('rootStore', () => {
let rootStore: RootStoreModel
beforeAll(() => {
jest.useFakeTimers()
})
beforeEach(async () => {
rootStore = await setupState()
})
afterAll(() => {
jest.clearAllMocks()
})
it('resolveName() handles inputs correctly', () => {
const spyMethod = jest
.spyOn(rootStore.api.com.atproto.handle, 'resolve')
.mockResolvedValue({success: true, headers: {}, data: {did: 'testdid'}})
rootStore.resolveName('teststring')
expect(spyMethod).toHaveBeenCalledWith({handle: 'teststring'})
expect(rootStore.resolveName('')).rejects.toThrow('Invalid handle: ""')
expect(rootStore.resolveName('did:123')).resolves.toReturnWith('did:123')
})
it('should call the clearAll() resets state correctly', () => {
rootStore.clearAll()
expect(rootStore.session.data).toEqual(null)
expect(rootStore.nav.tabs).toEqual([
{
fixedTabPurpose: 0,
history: [
{
id: expect.anything(),
ts: expect.anything(),
url: '/',
},
],
id: expect.anything(),
index: 0,
isNewTab: false,
},
{
fixedTabPurpose: 1,
history: [
{
id: expect.anything(),
ts: expect.anything(),
url: '/notifications',
},
],
id: expect.anything(),
index: 0,
isNewTab: false,
},
])
expect(rootStore.nav.tabIndex).toEqual(0)
expect(rootStore.me.did).toEqual('')
expect(rootStore.me.handle).toEqual('')
expect(rootStore.me.displayName).toEqual('')
expect(rootStore.me.description).toEqual('')
expect(rootStore.me.avatar).toEqual('')
expect(rootStore.me.notificationCount).toEqual(0)
expect(rootStore.me.memberships).toBeUndefined()
})
})

59
__tests__/state/models/shell-ui.test.ts 100644
View File

@ -0,0 +1,59 @@
import {
ConfirmModal,
ImageLightbox,
ShellUiModel,
} from './../../../src/state/models/shell-ui'
describe('ShellUiModel', () => {
let model: ShellUiModel
beforeEach(() => {
model = new ShellUiModel()
})
afterAll(() => {
jest.clearAllMocks()
})
it('should call the openModal & closeModal method', () => {
model.openModal(ConfirmModal)
expect(model.isModalActive).toEqual(true)
expect(model.activeModal).toEqual(ConfirmModal)
model.closeModal()
expect(model.isModalActive).toEqual(false)
expect(model.activeModal).toBeUndefined()
})
it('should call the openLightbox & closeLightbox method', () => {
model.openLightbox(new ImageLightbox('uri'))
expect(model.isLightboxActive).toEqual(true)
expect(model.activeLightbox).toEqual(new ImageLightbox('uri'))
model.closeLightbox()
expect(model.isLightboxActive).toEqual(false)
expect(model.activeLightbox).toBeUndefined()
})
it('should call the openComposer & closeComposer method', () => {
const composer = {
replyTo: {
uri: 'uri',
cid: 'cid',
text: 'text',
author: {
handle: 'handle',
displayName: 'name',
},
},
onPost: jest.fn(),
}
model.openComposer(composer)
expect(model.isComposerActive).toEqual(true)
expect(model.composerOpts).toEqual(composer)
model.closeComposer()
expect(model.isComposerActive).toEqual(false)
expect(model.composerOpts).toBeUndefined()
})
})

43
__tests__/view/com/composer/Autocomplete.test.tsx 100644
View File

@ -0,0 +1,43 @@
import React from 'react'
import {Autocomplete} from '../../../../src/view/com/composer/Autocomplete'
import {cleanup, fireEvent, render} from '../../../../jest/test-utils'
describe('Autocomplete', () => {
const onSelectMock = jest.fn()
const mockedProps = {
active: true,
items: [
{
handle: 'handle.test',
displayName: 'Test Display',
},
{
handle: 'handle2.test',
displayName: 'Test Display 2',
},
],
onSelect: onSelectMock,
}
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders a button for each user', async () => {
const {findAllByTestId} = render(<Autocomplete {...mockedProps} />)
const autocompleteButton = await findAllByTestId('autocompleteButton')
expect(autocompleteButton.length).toBe(2)
})
it('triggers onSelect by pressing the button', async () => {
const {findAllByTestId} = render(<Autocomplete {...mockedProps} />)
const autocompleteButton = await findAllByTestId('autocompleteButton')
fireEvent.press(autocompleteButton[0])
expect(onSelectMock).toHaveBeenCalledWith('handle.test')
fireEvent.press(autocompleteButton[1])
expect(onSelectMock).toHaveBeenCalledWith('handle2.test')
})
})

117
__tests__/view/com/composer/ComposePost.test.tsx 100644
View File

@ -0,0 +1,117 @@
import React from 'react'
import {ComposePost} from '../../../../src/view/com/composer/ComposePost'
import {cleanup, fireEvent, render, waitFor} from '../../../../jest/test-utils'
import * as apilib from '../../../../src/state/lib/api'
import {
mockedAutocompleteViewStore,
mockedRootStore,
} from '../../../../__mocks__/state-mock'
import Toast from 'react-native-root-toast'
describe('ComposePost', () => {
const mockedProps = {
replyTo: {
uri: 'testUri',
cid: 'testCid',
text: 'testText',
author: {
handle: 'test.handle',
displayName: 'test name',
avatar: '',
},
},
onPost: jest.fn(),
onClose: jest.fn(),
}
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders post composer', async () => {
const {findByTestId} = render(<ComposePost {...mockedProps} />)
const composePostView = await findByTestId('composePostView')
expect(composePostView).toBeTruthy()
})
it('closes composer', async () => {
const {findByTestId} = render(<ComposePost {...mockedProps} />)
const composerCancelButton = await findByTestId('composerCancelButton')
fireEvent.press(composerCancelButton)
expect(mockedProps.onClose).toHaveBeenCalled()
})
it('changes text and publishes post', async () => {
const postSpy = jest.spyOn(apilib, 'post').mockResolvedValue({
uri: '',
cid: '',
})
const toastSpy = jest.spyOn(Toast, 'show')
const wrapper = render(<ComposePost {...mockedProps} />)
const composerTextInput = await wrapper.findByTestId('composerTextInput')
fireEvent.changeText(composerTextInput, 'testing publish')
const composerPublishButton = await wrapper.findByTestId(
'composerPublishButton',
)
fireEvent.press(composerPublishButton)
expect(postSpy).toHaveBeenCalledWith(
mockedRootStore,
'testing publish',
'testUri',
[],
new Set<string>(),
expect.anything(),
)
// Waits for request to be resolved
await waitFor(() => {
expect(mockedProps.onPost).toHaveBeenCalled()
expect(mockedProps.onClose).toHaveBeenCalled()
expect(toastSpy).toHaveBeenCalledWith('Your reply has been published', {
animation: true,
duration: 3500,
hideOnPress: true,
position: 50,
shadow: true,
})
})
})
it('selects autocomplete item', async () => {
jest
.spyOn(React, 'useMemo')
.mockReturnValueOnce(mockedAutocompleteViewStore)
const {findAllByTestId} = render(<ComposePost {...mockedProps} />)
const autocompleteButton = await findAllByTestId('autocompleteButton')
fireEvent.press(autocompleteButton[0])
expect(mockedAutocompleteViewStore.setActive).toHaveBeenCalledWith(false)
})
it('selects photos', async () => {
const {findByTestId, queryByTestId} = render(
<ComposePost {...mockedProps} />,
)
let photoCarouselPickerView = queryByTestId('photoCarouselPickerView')
expect(photoCarouselPickerView).toBeFalsy()
const composerSelectPhotosButton = await findByTestId(
'composerSelectPhotosButton',
)
fireEvent.press(composerSelectPhotosButton)
photoCarouselPickerView = await findByTestId('photoCarouselPickerView')
expect(photoCarouselPickerView).toBeTruthy()
fireEvent.press(composerSelectPhotosButton)
photoCarouselPickerView = queryByTestId('photoCarouselPickerView')
expect(photoCarouselPickerView).toBeFalsy()
})
})

92
__tests__/view/com/composer/PhotoCarouselPicker.test.tsx 100644
View File

@ -0,0 +1,92 @@
import React from 'react'
import {PhotoCarouselPicker} from '../../../../src/view/com/composer/PhotoCarouselPicker'
import {cleanup, fireEvent, render} from '../../../../jest/test-utils'
import {
openCamera,
openCropper,
openPicker,
} from 'react-native-image-crop-picker'
describe('PhotoCarouselPicker', () => {
const mockedProps = {
selectedPhotos: ['mock-uri', 'mock-uri-2'],
onSelectPhotos: jest.fn(),
localPhotos: {
photos: [
{
node: {
image: {
uri: 'mock-uri',
},
},
},
],
},
}
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders carousel picker', async () => {
const {findByTestId} = render(<PhotoCarouselPicker {...mockedProps} />)
const photoCarouselPickerView = await findByTestId(
'photoCarouselPickerView',
)
expect(photoCarouselPickerView).toBeTruthy()
})
it('triggers openCamera', async () => {
const {findByTestId} = render(<PhotoCarouselPicker {...mockedProps} />)
const openCameraButton = await findByTestId('openCameraButton')
fireEvent.press(openCameraButton)
expect(openCamera).toHaveBeenCalledWith({
compressImageQuality: 1,
cropping: true,
forceJpg: true,
freeStyleCropEnabled: true,
height: 1000,
mediaType: 'photo',
width: 1000,
})
})
it('triggers openCropper', async () => {
const {findByTestId} = render(<PhotoCarouselPicker {...mockedProps} />)
const openSelectPhotoButton = await findByTestId('openSelectPhotoButton')
fireEvent.press(openSelectPhotoButton)
expect(openCropper).toHaveBeenCalledWith({
compressImageQuality: 1,
forceJpg: true,
freeStyleCropEnabled: true,
height: 1000,
mediaType: 'photo',
path: 'mock-uri',
width: 1000,
})
})
it('triggers openPicker', async () => {
const {findByTestId} = render(<PhotoCarouselPicker {...mockedProps} />)
const openGalleryButton = await findByTestId('openGalleryButton')
fireEvent.press(openGalleryButton)
expect(openPicker).toHaveBeenCalledWith({
maxFiles: 2,
mediaType: 'photo',
multiple: true,
})
expect(openCropper).toHaveBeenCalledWith({
compressImageQuality: 1,
forceJpg: true,
freeStyleCropEnabled: true,
height: 1000,
mediaType: 'photo',
path: 'mock-uri',
width: 1000,
})
})
})

70
__tests__/view/com/composer/SelectedPhoto.test.tsx 100644
View File

@ -0,0 +1,70 @@
import React from 'react'
import {SelectedPhoto} from '../../../../src/view/com/composer/SelectedPhoto'
import {cleanup, fireEvent, render} from '../../../../jest/test-utils'
describe('SelectedPhoto', () => {
const mockedProps = {
selectedPhotos: ['mock-uri', 'mock-uri-2'],
onSelectPhotos: jest.fn(),
}
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('has no photos to render', () => {
const {queryByTestId} = render(
<SelectedPhoto selectedPhotos={[]} onSelectPhotos={jest.fn()} />,
)
const selectedPhotosView = queryByTestId('selectedPhotosView')
expect(selectedPhotosView).toBeNull()
const selectedPhotoImage = queryByTestId('selectedPhotoImage')
expect(selectedPhotoImage).toBeNull()
})
it('has 1 photos to render', async () => {
const {findByTestId} = render(
<SelectedPhoto
selectedPhotos={['mock-uri']}
onSelectPhotos={jest.fn()}
/>,
)
const selectedPhotosView = await findByTestId('selectedPhotosView')
expect(selectedPhotosView).toBeTruthy()
const selectedPhotoImage = await findByTestId('selectedPhotoImage')
expect(selectedPhotoImage).toBeTruthy()
// @ts-expect-error
expect(selectedPhotoImage).toHaveStyle({width: 250})
})
it('has 2 photos to render', async () => {
const {findAllByTestId} = render(<SelectedPhoto {...mockedProps} />)
const selectedPhotoImage = await findAllByTestId('selectedPhotoImage')
expect(selectedPhotoImage[0]).toBeTruthy()
// @ts-expect-error
expect(selectedPhotoImage[0]).toHaveStyle({width: 175})
})
it('has 3 photos to render', async () => {
const {findAllByTestId} = render(
<SelectedPhoto
selectedPhotos={['mock-uri', 'mock-uri-2', 'mock-uri-3']}
onSelectPhotos={jest.fn()}
/>,
)
const selectedPhotoImage = await findAllByTestId('selectedPhotoImage')
expect(selectedPhotoImage[0]).toBeTruthy()
// @ts-expect-error
expect(selectedPhotoImage[0]).toHaveStyle({width: 85})
})
it('removes a photo', async () => {
const {findAllByTestId} = render(<SelectedPhoto {...mockedProps} />)
const removePhotoButton = await findAllByTestId('removePhotoButton')
fireEvent.press(removePhotoButton[0])
expect(mockedProps.onSelectPhotos).toHaveBeenCalledWith(['mock-uri-2'])
})
})

60
__tests__/view/com/login/CreateAccount.test.tsx 100644
View File

@ -0,0 +1,60 @@
import React from 'react'
import {Keyboard} from 'react-native'
import {CreateAccount} from '../../../../src/view/com/login/CreateAccount'
import {cleanup, fireEvent, render} from '../../../../jest/test-utils'
import {
mockedLogStore,
mockedRootStore,
mockedSessionStore,
mockedShellStore,
} from '../../../../__mocks__/state-mock'
describe('CreateAccount', () => {
const mockedProps = {
onPressBack: jest.fn(),
}
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders form and creates new account', async () => {
const {findByTestId} = render(<CreateAccount {...mockedProps} />)
const registerEmailInput = await findByTestId('registerEmailInput')
expect(registerEmailInput).toBeTruthy()
fireEvent.changeText(registerEmailInput, 'test@email.com')
const registerHandleInput = await findByTestId('registerHandleInput')
expect(registerHandleInput).toBeTruthy()
fireEvent.changeText(registerHandleInput, 'test.handle')
const registerPasswordInput = await findByTestId('registerPasswordInput')
expect(registerPasswordInput).toBeTruthy()
fireEvent.changeText(registerPasswordInput, 'testpass')
const registerIs13Input = await findByTestId('registerIs13Input')
expect(registerIs13Input).toBeTruthy()
fireEvent.press(registerIs13Input)
const createAccountButton = await findByTestId('createAccountButton')
expect(createAccountButton).toBeTruthy()
fireEvent.press(createAccountButton)
expect(mockedSessionStore.createAccount).toHaveBeenCalled()
})
it('renders and selects service', async () => {
const keyboardSpy = jest.spyOn(Keyboard, 'dismiss')
const {findByTestId} = render(<CreateAccount {...mockedProps} />)
const registerSelectServiceButton = await findByTestId(
'registerSelectServiceButton',
)
expect(registerSelectServiceButton).toBeTruthy()
fireEvent.press(registerSelectServiceButton)
expect(mockedShellStore.openModal).toHaveBeenCalled()
expect(keyboardSpy).toHaveBeenCalled()
})
})

128
__tests__/view/com/login/Signin.test.tsx 100644
View File

@ -0,0 +1,128 @@
import React from 'react'
import {Signin} from '../../../../src/view/com/login/Signin'
import {cleanup, fireEvent, render} from '../../../../jest/test-utils'
import {SessionServiceClient, sessionClient as AtpApi} from '@atproto/api'
import {
mockedLogStore,
mockedRootStore,
mockedSessionStore,
mockedShellStore,
} from '../../../../__mocks__/state-mock'
import {Keyboard} from 'react-native'
describe('Signin', () => {
const requestPasswordResetMock = jest.fn()
const resetPasswordMock = jest.fn()
jest.spyOn(AtpApi, 'service').mockReturnValue({
com: {
atproto: {
account: {
requestPasswordReset: requestPasswordResetMock,
resetPassword: resetPasswordMock,
},
},
},
} as unknown as SessionServiceClient)
const mockedProps = {
onPressBack: jest.fn(),
}
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders logs in form', async () => {
const {findByTestId} = render(<Signin {...mockedProps} />)
const loginFormView = await findByTestId('loginFormView')
expect(loginFormView).toBeTruthy()
const loginUsernameInput = await findByTestId('loginUsernameInput')
expect(loginUsernameInput).toBeTruthy()
fireEvent.changeText(loginUsernameInput, 'testusername')
const loginPasswordInput = await findByTestId('loginPasswordInput')
expect(loginPasswordInput).toBeTruthy()
fireEvent.changeText(loginPasswordInput, 'test pass')
const loginNextButton = await findByTestId('loginNextButton')
expect(loginNextButton).toBeTruthy()
fireEvent.press(loginNextButton)
expect(mockedSessionStore.login).toHaveBeenCalled()
})
it('renders selects service from login form', async () => {
const keyboardSpy = jest.spyOn(Keyboard, 'dismiss')
const {findByTestId} = render(<Signin {...mockedProps} />)
const loginSelectServiceButton = await findByTestId(
'loginSelectServiceButton',
)
expect(loginSelectServiceButton).toBeTruthy()
fireEvent.press(loginSelectServiceButton)
expect(mockedShellStore.openModal).toHaveBeenCalled()
expect(keyboardSpy).toHaveBeenCalled()
})
it('renders new password form', async () => {
const {findByTestId} = render(<Signin {...mockedProps} />)
const forgotPasswordButton = await findByTestId('forgotPasswordButton')
expect(forgotPasswordButton).toBeTruthy()
fireEvent.press(forgotPasswordButton)
const forgotPasswordView = await findByTestId('forgotPasswordView')
expect(forgotPasswordView).toBeTruthy()
const forgotPasswordEmail = await findByTestId('forgotPasswordEmail')
expect(forgotPasswordEmail).toBeTruthy()
fireEvent.changeText(forgotPasswordEmail, 'test@email.com')
const newPasswordButton = await findByTestId('newPasswordButton')
expect(newPasswordButton).toBeTruthy()
fireEvent.press(newPasswordButton)
expect(requestPasswordResetMock).toHaveBeenCalled()
const newPasswordView = await findByTestId('newPasswordView')
expect(newPasswordView).toBeTruthy()
const newPasswordInput = await findByTestId('newPasswordInput')
expect(newPasswordInput).toBeTruthy()
const resetCodeInput = await findByTestId('resetCodeInput')
expect(resetCodeInput).toBeTruthy()
fireEvent.changeText(newPasswordInput, 'test pass')
fireEvent.changeText(resetCodeInput, 'test reset code')
const setNewPasswordButton = await findByTestId('setNewPasswordButton')
expect(setNewPasswordButton).toBeTruthy()
fireEvent.press(setNewPasswordButton)
expect(resetPasswordMock).toHaveBeenCalled()
})
it('renders forgot password form', async () => {
const {findByTestId} = render(<Signin {...mockedProps} />)
const forgotPasswordButton = await findByTestId('forgotPasswordButton')
expect(forgotPasswordButton).toBeTruthy()
fireEvent.press(forgotPasswordButton)
const forgotPasswordSelectServiceButton = await findByTestId(
'forgotPasswordSelectServiceButton',
)
expect(forgotPasswordSelectServiceButton).toBeTruthy()
fireEvent.press(forgotPasswordSelectServiceButton)
expect(mockedShellStore.openModal).toHaveBeenCalled()
})
})

109
__tests__/view/com/profile/ProfileHeader.test.tsx 100644
View File

@ -0,0 +1,109 @@
import React from 'react'
import {cleanup, fireEvent, render} from '../../../../jest/test-utils'
import {ProfileViewModel} from '../../../../src/state/models/profile-view'
import {ProfileHeader} from '../../../../src/view/com/profile/ProfileHeader'
import {
mockedNavigationStore,
mockedProfileStore,
mockedShellStore,
} from '../../../../__mocks__/state-mock'
describe('ProfileHeader', () => {
const mockedProps = {
view: mockedProfileStore,
onRefreshAll: jest.fn(),
}
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders ErrorMessage on error', async () => {
const {findByTestId} = render(
<ProfileHeader
{...{
view: {
...mockedProfileStore,
hasError: true,
} as ProfileViewModel,
onRefreshAll: jest.fn(),
}}
/>,
)
const profileHeaderHasError = await findByTestId('profileHeaderHasError')
expect(profileHeaderHasError).toBeTruthy()
})
it('presses and opens edit profile', async () => {
const {findByTestId} = render(<ProfileHeader {...mockedProps} />)
const profileHeaderEditProfileButton = await findByTestId(
'profileHeaderEditProfileButton',
)
expect(profileHeaderEditProfileButton).toBeTruthy()
fireEvent.press(profileHeaderEditProfileButton)
expect(mockedShellStore.openModal).toHaveBeenCalled()
})
it('presses and opens followers page', async () => {
const {findByTestId} = render(<ProfileHeader {...mockedProps} />)
const profileHeaderFollowersButton = await findByTestId(
'profileHeaderFollowersButton',
)
expect(profileHeaderFollowersButton).toBeTruthy()
fireEvent.press(profileHeaderFollowersButton)
expect(mockedNavigationStore.navigate).toHaveBeenCalledWith(
'/profile/testhandle/followers',
)
})
it('presses and opens avatar modal', async () => {
const {findByTestId} = render(<ProfileHeader {...mockedProps} />)
const profileHeaderAviButton = await findByTestId('profileHeaderAviButton')
expect(profileHeaderAviButton).toBeTruthy()
fireEvent.press(profileHeaderAviButton)
expect(mockedShellStore.openLightbox).toHaveBeenCalled()
})
it('presses and opens follows page', async () => {
const {findByTestId} = render(<ProfileHeader {...mockedProps} />)
const profileHeaderFollowsButton = await findByTestId(
'profileHeaderFollowsButton',
)
expect(profileHeaderFollowsButton).toBeTruthy()
fireEvent.press(profileHeaderFollowsButton)
expect(mockedNavigationStore.navigate).toHaveBeenCalledWith(
'/profile/testhandle/follows',
)
})
it('toggles following', async () => {
const {findByTestId} = render(
<ProfileHeader
{...{
view: {
...mockedProfileStore,
did: 'test did 2',
} as ProfileViewModel,
onRefreshAll: jest.fn(),
}}
/>,
)
const profileHeaderToggleFollowButton = await findByTestId(
'profileHeaderToggleFollowButton',
)
expect(profileHeaderToggleFollowButton).toBeTruthy()
fireEvent.press(profileHeaderToggleFollowButton)
expect(mockedProps.view.toggleFollowing).toHaveBeenCalled()
})
})

17
__tests__/view/lib/useAnimatedValue.test.tsx 100644
View File

@ -0,0 +1,17 @@
import {renderHook} from '../../../jest/test-utils'
import {useAnimatedValue} from '../../../src/view/lib/hooks/useAnimatedValue'
describe('useAnimatedValue', () => {
it('creates an Animated.Value with the initial value passed to the hook', () => {
const {result} = renderHook(() => useAnimatedValue(10))
// @ts-expect-error
expect(result.current.__getValue()).toEqual(10)
})
it('returns the same Animated.Value instance on subsequent renders', () => {
const {result, rerender} = renderHook(() => useAnimatedValue(10))
const firstValue = result.current
rerender({})
expect(result.current).toBe(firstValue)
})
})

49
__tests__/view/lib/useOnMainScroll.test.tsx 100644
View File

@ -0,0 +1,49 @@
import React from 'react'
import {fireEvent, render} from '../../../jest/test-utils'
import {Home} from '../../../src/view/screens/Home'
import {mockedRootStore, mockedShellStore} from '../../../__mocks__/state-mock'
describe('useOnMainScroll', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {},
visible: true,
}
it('toggles minimalShellMode to true', () => {
jest.useFakeTimers()
const {getByTestId} = render(<Home {...mockedProps} />)
fireEvent.scroll(getByTestId('homeFeed'), {
nativeEvent: {
contentOffset: {y: 20},
contentSize: {height: 100},
layoutMeasurement: {height: 50},
},
})
expect(mockedRootStore.shell.setMinimalShellMode).toHaveBeenCalledWith(true)
})
it('toggles minimalShellMode to false', () => {
jest.useFakeTimers()
const {getByTestId} = render(<Home {...mockedProps} />, {
...mockedRootStore,
shell: {
...mockedShellStore,
minimalShellMode: true,
},
})
fireEvent.scroll(getByTestId('homeFeed'), {
nativeEvent: {
contentOffset: {y: 0},
contentSize: {height: 100},
layoutMeasurement: {height: 50},
},
})
expect(mockedRootStore.shell.setMinimalShellMode).toHaveBeenCalledWith(
false,
)
})
})

16
__tests__/view/screens/Contacts.test.tsx
View File

@ -1,16 +0,0 @@
import React from 'react'
import {Contacts} from '../../../src/view/screens/Contacts'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('Contacts', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<Contacts {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

16
__tests__/view/screens/Home.test.tsx
View File

@ -1,16 +0,0 @@
import React from 'react'
import {Home} from '../../../src/view/screens/Home'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('Home', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<Home {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

36
__tests__/view/screens/Login.test.tsx
View File

@ -1,11 +1,37 @@
import React from 'react'
import {Login} from '../../../src/view/screens/Login'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
import {cleanup, fireEvent, render} from '../../../jest/test-utils'
describe('Login', () => {
it('renders correctly', () => {
const tree = renderer.create(<Login />).toJSON()
expect(tree).toMatchSnapshot()
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders initial screen', () => {
const {getByTestId} = render(<Login />)
const signUpScreen = getByTestId('signinOrCreateAccount')
expect(signUpScreen).toBeTruthy()
})
it('renders Signin screen', () => {
const {getByTestId} = render(<Login />)
const signInButton = getByTestId('signInButton')
fireEvent.press(signInButton)
const signInScreen = getByTestId('signIn')
expect(signInScreen).toBeTruthy()
})
it('renders CreateAccount screen', () => {
const {getByTestId} = render(<Login />)
const createAccountButton = getByTestId('createAccountButton')
fireEvent.press(createAccountButton)
const createAccountScreen = getByTestId('createAccount')
expect(createAccountScreen).toBeTruthy()
})
})

20
__tests__/view/screens/NotFound.test.tsx
View File

@ -1,11 +1,21 @@
import React from 'react'
import {NotFound} from '../../../src/view/screens/NotFound'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
import {cleanup, fireEvent, render} from '../../../jest/test-utils'
import {mockedNavigationStore} from '../../../__mocks__/state-mock'
describe('NotFound', () => {
it('renders correctly', () => {
const tree = renderer.create(<NotFound />).toJSON()
expect(tree).toMatchSnapshot()
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('navigates home', async () => {
const navigationSpy = jest.spyOn(mockedNavigationStore, 'navigate')
const {getByTestId} = render(<NotFound />)
const navigateHomeButton = getByTestId('navigateHomeButton')
fireEvent.press(navigateHomeButton)
expect(navigationSpy).toHaveBeenCalledWith('/')
})
})

16
__tests__/view/screens/Notifications.test.tsx
View File

@ -1,16 +0,0 @@
import React from 'react'
import {Notifications} from '../../../src/view/screens/Notifications'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('Notifications', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<Notifications {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

11
__tests__/view/screens/Onboard.test.tsx
View File

@ -1,11 +0,0 @@
import React from 'react'
import {Onboard} from '../../../src/view/screens/Onboard'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('Onboard', () => {
it('renders correctly', () => {
const tree = renderer.create(<Onboard />).toJSON()
expect(tree).toMatchSnapshot()
})
})

19
__tests__/view/screens/PostDownvotedBy.test.tsx
View File

@ -1,19 +0,0 @@
import React from 'react'
import {PostDownvotedBy} from '../../../src/view/screens/PostDownvotedBy'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('PostDownvotedBy', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {
name: 'test name',
rkey: '123123123',
},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<PostDownvotedBy {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

19
__tests__/view/screens/PostRepostedBy.test.tsx
View File

@ -1,19 +0,0 @@
import React from 'react'
import {PostRepostedBy} from '../../../src/view/screens/PostRepostedBy'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('PostRepostedBy', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {
name: 'test name',
rkey: '123123123',
},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<PostRepostedBy {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

19
__tests__/view/screens/PostThread.test.tsx
View File

@ -1,19 +0,0 @@
import React from 'react'
import {PostThread} from '../../../src/view/screens/PostThread'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('PostThread', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {
name: 'test name',
rkey: '123123123',
},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<PostThread {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

19
__tests__/view/screens/PostUpvotedBy.test.tsx
View File

@ -1,19 +0,0 @@
import React from 'react'
import {PostUpvotedBy} from '../../../src/view/screens/PostUpvotedBy'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('PostUpvotedBy', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {
name: 'test name',
rkey: '123123123',
},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<PostUpvotedBy {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

19
__tests__/view/screens/Profile.test.tsx
View File

@ -1,19 +0,0 @@
import React from 'react'
import {Profile} from '../../../src/view/screens/Profile'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('Profile', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {
name: 'test name',
user: 'test.user',
},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<Profile {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

18
__tests__/view/screens/ProfileFollowers.test.tsx
View File

@ -1,18 +0,0 @@
import React from 'react'
import {ProfileFollowers} from '../../../src/view/screens/ProfileFollowers'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('ProfileFollowers', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {
name: 'test name',
},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<ProfileFollowers {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

18
__tests__/view/screens/ProfileFollows.test.tsx
View File

@ -1,18 +0,0 @@
import React from 'react'
import {ProfileFollows} from '../../../src/view/screens/ProfileFollows'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('ProfileFollows', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {
name: 'test name',
},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<ProfileFollows {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

18
__tests__/view/screens/ProfileMembers.test.tsx
View File

@ -1,18 +0,0 @@
import React from 'react'
import {ProfileMembers} from '../../../src/view/screens/ProfileMembers'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('ProfileMembers', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {
name: 'test name',
},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<ProfileMembers {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

22
__tests__/view/screens/Search.test.tsx
View File

@ -1,9 +1,9 @@
import React from 'react'
import {Search} from '../../../src/view/screens/Search'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
import {cleanup, fireEvent, render} from '../../../jest/test-utils'
describe('Search', () => {
jest.useFakeTimers()
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {
@ -11,8 +11,20 @@ describe('Search', () => {
},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<Search {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders with query', async () => {
const {findByTestId} = render(<Search {...mockedProps} />)
const searchTextInput = await findByTestId('searchTextInput')
expect(searchTextInput).toBeTruthy()
fireEvent.changeText(searchTextInput, 'test')
const searchScrollView = await findByTestId('searchScrollView')
expect(searchScrollView).toBeTruthy()
})
})

16
__tests__/view/screens/Settings.test.tsx
View File

@ -1,16 +0,0 @@
import React from 'react'
import {Settings} from '../../../src/view/screens/Settings'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('Settings', () => {
const mockedProps = {
navIdx: [0, 0] as [number, number],
params: {},
visible: true,
}
it('renders correctly', () => {
const tree = renderer.create(<Settings {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

205
__tests__/view/screens/__snapshots__/Contacts.test.tsx.snap
View File

@ -1,205 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Contacts renders correctly 1`] = `
<View>
<View
style={
Object {
"backgroundColor": "#ffffff",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"fontSize": 30,
"fontWeight": "bold",
"paddingHorizontal": 12,
"paddingVertical": 6,
},
]
}
>
Contacts
</Text>
</View>
<View
style={
Object {
"backgroundColor": "#ffffff",
}
}
>
<View
style={
Object {
"backgroundColor": "#f8f3f3",
"borderRadius": 4,
"flexDirection": "row",
"marginBottom": 6,
"marginHorizontal": 10,
"paddingHorizontal": 8,
"paddingVertical": 8,
}
}
>
<
icon="magnifying-glass"
size={16}
style={
Object {
"color": "#645454",
"marginRight": 8,
}
}
/>
<TextInput
onChangeText={[Function]}
placeholder="Search"
placeholderTextColor="#968d8d"
style={
Object {
"color": "#000000",
"flex": 1,
}
}
value=""
/>
</View>
</View>
<View
onLayout={[Function]}
style={
Array [
Object {
"backgroundColor": "#ffffff",
"flexDirection": "row",
"paddingBottom": 12,
"paddingHorizontal": 14,
"paddingTop": 8,
},
]
}
>
<View
collapsable={false}
style={
Object {
"backgroundColor": "#000000",
"bottom": 0,
"height": 4,
"left": 0,
"position": "absolute",
"width": 0,
}
}
/>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"marginRight": 14,
"paddingHorizontal": 10,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 16,
"fontWeight": "600",
},
]
}
>
All
</Text>
</View>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"marginRight": 14,
"paddingHorizontal": 10,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#645454",
"fontSize": 16,
"fontWeight": "600",
},
]
}
>
Following
</Text>
</View>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"marginRight": 14,
"paddingHorizontal": 10,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#645454",
"fontSize": 16,
"fontWeight": "600",
},
]
}
>
Scenes
</Text>
</View>
</View>
</View>
`;

594
__tests__/view/screens/__snapshots__/Home.test.tsx.snap
View File

@ -1,594 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Home renders correctly 1`] = `
<View
style={
Object {
"flex": 1,
}
}
>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Bluesky
</Text>
<Text
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#968d8d",
"fontSize": 18,
"marginLeft": 6,
"maxWidth": 200,
},
]
}
>
Private Beta
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View
style={
Object {
"flex": 1,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 6,
"flexDirection": "row",
"margin": 2,
"marginBottom": 0,
"opacity": 1,
"paddingHorizontal": 10,
"paddingVertical": 10,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"opacity": 1,
"width": 50,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={50}
bbWidth={50}
focusable={false}
height={50}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 50,
"width": 50,
},
]
}
vbHeight={100}
vbWidth={100}
width={50}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
style={
Object {
"flex": 1,
"marginLeft": 10,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#968d8d",
"fontSize": 17,
},
]
}
>
What's up?
</Text>
</View>
<View
style={
Object {
"backgroundColor": "#f8f3f3",
"borderRadius": 30,
"paddingHorizontal": 14,
"paddingVertical": 6,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#645454",
},
]
}
>
Post
</Text>
</View>
</View>
</View>
</View>
`;

371
__tests__/view/screens/__snapshots__/Login.test.tsx.snap
View File

@ -1,371 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Login renders correctly 1`] = `
<View
style={
Object {
"flex": 1,
}
}
>
<View
style={
Object {
"flex": 2,
"justifyContent": "center",
}
}
>
<View
style={
Object {
"flexDirection": "row",
"justifyContent": "center",
}
}
>
<RNSVGSvgView
bbHeight="100"
bbWidth="100"
focusable={false}
height="100"
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 100,
"width": 100,
},
]
}
width="100"
>
<RNSVGGroup>
<RNSVGCircle
cx="50"
cy="50"
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
r="46"
stroke={4294967295}
strokeWidth={2}
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth={1}
x1="30"
x2="30"
y1="0"
y2="100"
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth={1}
x1="74"
x2="74"
y1="0"
y2="100"
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth={1}
x1="0"
x2="100"
y1="22"
y2="22"
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth={1}
x1="0"
x2="100"
y1="74"
y2="74"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={null}
font={
Object {
"fontSize": "60",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
rotate={Array []}
stroke={4294967295}
strokeWidth={2}
x={
Array [
"52",
]
}
y={
Array [
"70",
]
}
>
<RNSVGTSpan
content="B"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 68,
"fontWeight": "bold",
"textAlign": "center",
},
]
}
>
Bluesky
</Text>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 18,
"textAlign": "center",
},
]
}
>
[ private beta ]
</Text>
</View>
<View
style={
Object {
"flex": 1,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"backgroundColor": "#0085ff",
"borderColor": "#ffffff",
"borderRadius": 10,
"borderWidth": 1,
"marginBottom": 20,
"marginHorizontal": 20,
"opacity": 1,
"paddingVertical": 16,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 18,
"fontWeight": "bold",
"textAlign": "center",
},
]
}
>
Create a new account
</Text>
</View>
<View
style={
Object {
"marginBottom": 20,
}
}
>
<RNSVGSvgView
bbHeight="1"
bbWidth={750}
focusable={false}
height="1"
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"position": "absolute",
"top": 10,
},
Object {
"flex": 0,
"height": 1,
"width": 750,
},
]
}
width={750}
>
<RNSVGGroup>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth="1"
x1="30"
x2={355}
y1="0"
y2="0"
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth="1"
x1={395}
x2={720}
y1="0"
y2="0"
/>
</RNSVGGroup>
</RNSVGSvgView>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 16,
"textAlign": "center",
},
]
}
>
or
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"backgroundColor": "#0085ff",
"borderColor": "#ffffff",
"borderRadius": 10,
"borderWidth": 1,
"marginBottom": 20,
"marginHorizontal": 20,
"opacity": 1,
"paddingVertical": 16,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 18,
"fontWeight": "bold",
"textAlign": "center",
},
]
}
>
Sign in
</Text>
</View>
</View>
</View>
`;

431
__tests__/view/screens/__snapshots__/NotFound.test.tsx.snap
View File

@ -1,431 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`NotFound renders correctly 1`] = `
<View>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Page not found
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View
style={
Object {
"alignItems": "center",
"justifyContent": "center",
"paddingTop": 100,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"fontSize": 40,
"fontWeight": "bold",
},
]
}
>
Page not found
</Text>
<View
accessibilityRole="button"
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"opacity": 1,
}
}
>
<View
style={
Array [
Object {},
]
}
>
<Text
style={
Array [
Object {
"color": "#007AFF",
"fontSize": 18,
"margin": 8,
"textAlign": "center",
},
]
}
>
Home
</Text>
</View>
</View>
</View>
</View>
`;

378
__tests__/view/screens/__snapshots__/Notifications.test.tsx.snap
View File

@ -1,378 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Notifications renders correctly 1`] = `
<View
style={
Object {
"flex": 1,
}
}
>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Notifications
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View
style={
Object {
"flex": 1,
}
}
/>
</View>
`;

388
__tests__/view/screens/__snapshots__/Onboard.test.tsx.snap
View File

@ -1,388 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Onboard renders correctly 1`] = `
<View
style={
Object {
"backgroundColor": "#fff",
"flex": 1,
}
}
>
<RCTSafeAreaView
emulateUnlessSupported={true}
style={
Object {
"flex": 1,
}
}
>
<View
onLayout={[Function]}
style={
Array [
Object {
"flex": 1,
"overflow": "hidden",
},
undefined,
]
}
>
<RNCViewPager
collapsable={false}
initialPage={0}
keyboardDismissMode="on-drag"
layout={
Object {
"height": 0,
"width": 750,
}
}
layoutDirection="ltr"
onMoveShouldSetResponderCapture={[Function]}
onPageScroll={[Function]}
onPageScrollStateChanged={[Function]}
onPageSelected={[Function]}
scrollEnabled={true}
style={
Object {
"flex": 1,
}
}
>
<View
collapsable={false}
style={
Object {
"bottom": 0,
"left": 0,
"position": "absolute",
"right": 0,
"top": 0,
}
}
>
<View
accessibilityElementsHidden={false}
importantForAccessibility="auto"
style={
Array [
Object {
"flex": 1,
"overflow": "hidden",
},
Object {
"width": 750,
},
Array [
undefined,
Object {
"bottom": 0,
"left": 0,
"position": "absolute",
"right": 0,
"top": 0,
},
],
]
}
>
<View
style={
Object {
"flex": 1,
"paddingHorizontal": 16,
"paddingTop": 80,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"fontSize": 42,
"fontWeight": "bold",
"marginBottom": 16,
"textAlign": "center",
},
Object {
"fontWeight": "400",
},
Object {
"lineHeight": 60,
"paddingBottom": 50,
"paddingTop": 50,
},
],
]
}
>
Welcome to
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"fontWeight": "bold",
},
Object {
"color": "#0085ff",
},
Object {
"fontSize": 56,
},
],
]
}
>
Bluesky
</Text>
</Text>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"fontSize": 18,
"marginBottom": 16,
"textAlign": "center",
},
Object {
"fontSize": 24,
},
],
]
}
>
Let's do a quick tour through the new features.
</Text>
</View>
</View>
</View>
<View
collapsable={false}
style={
Object {
"bottom": 0,
"left": 0,
"position": "absolute",
"right": 0,
"top": 0,
}
}
>
<View
accessibilityElementsHidden={true}
importantForAccessibility="no-hide-descendants"
style={
Array [
Object {
"flex": 1,
"overflow": "hidden",
},
Object {
"width": 750,
},
Array [
undefined,
Object {
"bottom": 0,
"left": 0,
"position": "absolute",
"right": 0,
"top": 0,
},
],
]
}
/>
</View>
</RNCViewPager>
<View
style={
Object {
"flexDirection": "row",
}
}
>
<View
style={
Object {
"flex": 1,
}
}
/>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"opacity": 1,
"padding": 16,
}
}
>
<Text
collapsable={false}
style={
Object {
"opacity": 1,
}
}
>
°
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"opacity": 1,
"padding": 16,
}
}
>
<Text
collapsable={false}
style={
Object {
"opacity": 0.5,
}
}
>
°
</Text>
</View>
<View
style={
Object {
"flex": 1,
}
}
/>
</View>
</View>
<View
style={
Object {
"flexDirection": "row",
"paddingBottom": 24,
"paddingHorizontal": 32,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"opacity": 1,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#0085ff",
},
Object {
"fontSize": 18,
},
],
]
}
>
Skip
</Text>
</View>
<View
style={
Object {
"flex": 1,
}
}
/>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"opacity": 1,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#0085ff",
},
Object {
"fontSize": 18,
},
],
]
}
>
Next
</Text>
</View>
</View>
</RCTSafeAreaView>
</View>
`;

368
__tests__/view/screens/__snapshots__/PostDownvotedBy.test.tsx.snap
View File

@ -1,368 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`PostDownvotedBy renders correctly 1`] = `
<View>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Downvoted by
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View>
<ActivityIndicator />
</View>
</View>
`;

368
__tests__/view/screens/__snapshots__/PostRepostedBy.test.tsx.snap
View File

@ -1,368 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`PostRepostedBy renders correctly 1`] = `
<View>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Reposted by
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View>
<ActivityIndicator />
</View>
</View>
`;

437
__tests__/view/screens/__snapshots__/PostThread.test.tsx.snap
View File

@ -1,437 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`PostThread renders correctly 1`] = `
<View
style={
Object {
"flex": 1,
}
}
>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Post
</Text>
<Text
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#968d8d",
"fontSize": 18,
"marginLeft": 6,
"maxWidth": 200,
},
]
}
>
by test name
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View
style={
Object {
"flex": 1,
}
}
>
<RCTScrollView
contentContainerStyle={
Object {
"paddingBottom": 200,
}
}
data={Array []}
getItem={[Function]}
getItemCount={[Function]}
keyExtractor={[Function]}
onContentSizeChange={[Function]}
onLayout={[Function]}
onMomentumScrollBegin={[Function]}
onMomentumScrollEnd={[Function]}
onRefresh={[Function]}
onScroll={[Function]}
onScrollBeginDrag={[Function]}
onScrollEndDrag={[Function]}
onScrollToIndexFailed={[Function]}
refreshControl={
<RefreshControlMock
onRefresh={[Function]}
refreshing={false}
/>
}
refreshing={false}
removeClippedSubviews={false}
renderItem={[Function]}
scrollEventThrottle={50}
stickyHeaderIndices={Array []}
style={
Object {
"flex": 1,
}
}
viewabilityConfigCallbackPairs={Array []}
>
<RCTRefreshControl />
<View />
</RCTScrollView>
</View>
</View>
`;

368
__tests__/view/screens/__snapshots__/PostUpvotedBy.test.tsx.snap
View File

@ -1,368 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`PostUpvotedBy renders correctly 1`] = `
<View>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Upvoted by
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View>
<ActivityIndicator />
</View>
</View>
`;

513
__tests__/view/screens/__snapshots__/Profile.test.tsx.snap
View File

@ -1,513 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Profile renders correctly 1`] = `
<View
style={
Object {
"flexDirection": "column",
"height": "100%",
}
}
>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
test name
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View
style={
Object {
"backgroundColor": "#ffffff",
}
}
>
<View
style={
Array [
Object {
"backgroundColor": "#e7e9ea",
"borderRadius": 6,
"height": 120,
"overflow": "hidden",
"width": "100%",
},
undefined,
]
}
>
<View
style={
Object {
"backgroundColor": "#e7e9ea",
"height": 120,
"width": "100%",
}
}
/>
</View>
<View
style={
Object {
"backgroundColor": "#ffffff",
"borderColor": "#ffffff",
"borderRadius": 42,
"borderWidth": 2,
"height": 84,
"left": 10,
"position": "absolute",
"top": 80,
"width": 84,
}
}
>
<View
style={
Array [
Object {
"backgroundColor": "#e7e9ea",
"borderRadius": 6,
"height": 80,
"overflow": "hidden",
"width": 80,
},
Object {
"borderRadius": 40,
},
]
}
>
<View
style={
Object {
"backgroundColor": "#e7e9ea",
"height": 80,
"width": 80,
}
}
/>
</View>
</View>
<View
style={
Object {
"paddingBottom": 4,
"paddingHorizontal": 14,
"paddingTop": 8,
}
}
>
<View
style={
Array [
Object {
"flexDirection": "row",
"marginBottom": 12,
"marginLeft": "auto",
},
]
}
>
<View
style={
Array [
Object {
"backgroundColor": "#e7e9ea",
"borderRadius": 6,
"height": 31,
"overflow": "hidden",
"width": 100,
},
Object {
"borderRadius": 50,
},
]
}
>
<View
style={
Object {
"backgroundColor": "#e7e9ea",
"height": 31,
"width": 100,
}
}
/>
</View>
</View>
<View
style={Object {}}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"fontSize": 28,
"fontWeight": "bold",
},
]
}
>
</Text>
</View>
</View>
</View>
</View>
`;

386
__tests__/view/screens/__snapshots__/ProfileFollowers.test.tsx.snap
View File

@ -1,386 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`ProfileFollowers renders correctly 1`] = `
<View>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Followers
</Text>
<Text
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#968d8d",
"fontSize": 18,
"marginLeft": 6,
"maxWidth": 200,
},
]
}
>
of test name
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View>
<ActivityIndicator />
</View>
</View>
`;

386
__tests__/view/screens/__snapshots__/ProfileFollows.test.tsx.snap
View File

@ -1,386 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`ProfileFollows renders correctly 1`] = `
<View>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Followed
</Text>
<Text
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#968d8d",
"fontSize": 18,
"marginLeft": 6,
"maxWidth": 200,
},
]
}
>
by test name
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View>
<ActivityIndicator />
</View>
</View>
`;

386
__tests__/view/screens/__snapshots__/ProfileMembers.test.tsx.snap
View File

@ -1,386 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`ProfileMembers renders correctly 1`] = `
<View>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Members
</Text>
<Text
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#968d8d",
"fontSize": 18,
"marginLeft": 6,
"maxWidth": 200,
},
]
}
>
of test name
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View>
<ActivityIndicator />
</View>
</View>
`;

514
__tests__/view/screens/__snapshots__/Search.test.tsx.snap
View File

@ -1,514 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Search renders correctly 1`] = `
<View
style={
Object {
"backgroundColor": "#ffffff",
"flex": 1,
}
}
>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Search
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View
style={
Object {
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingHorizontal": 16,
"paddingVertical": 16,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={24}
bbWidth={24}
color={4290886073}
fill="none"
focusable={false}
height={24}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={2}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"alignSelf": "center",
"color": "#c1b9b9",
"marginRight": 10,
},
Object {
"flex": 0,
"height": 24,
"width": 24,
},
]
}
tintColor={4290886073}
vbHeight={24}
vbWidth={24}
width={24}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={2}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
<TextInput
onChangeText={[Function]}
placeholder="Type your query here..."
placeholderTextColor="#968d8d"
returnKeyType="search"
selectTextOnFocus={true}
style={
Object {
"color": "#000000",
"flex": 1,
"fontSize": 16,
}
}
/>
</View>
<View
style={
Object {
"backgroundColor": "#f8f3f3",
"flex": 1,
}
}
>
<View
style={
Object {
"flex": 1,
}
}
>
<View
style={
Object {
"backgroundColor": "#f8f3f3",
"flex": 1,
}
}
>
<RCTScrollView
data={Array []}
getItem={[Function]}
getItemCount={[Function]}
keyExtractor={[Function]}
onContentSizeChange={[Function]}
onLayout={[Function]}
onMomentumScrollBegin={[Function]}
onMomentumScrollEnd={[Function]}
onScroll={[Function]}
onScrollBeginDrag={[Function]}
onScrollEndDrag={[Function]}
removeClippedSubviews={false}
renderItem={[Function]}
scrollEventThrottle={50}
stickyHeaderIndices={Array []}
style={
Object {
"flex": 1,
}
}
viewabilityConfigCallbackPairs={Array []}
>
<View />
</RCTScrollView>
</View>
</View>
</View>
</View>
`;

631
__tests__/view/screens/__snapshots__/Settings.test.tsx.snap
View File

@ -1,631 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Settings renders correctly 1`] = `
<View
style={
Array [
Object {
"flex": 1,
},
]
}
>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"flexDirection": "row",
"paddingBottom": 6,
"paddingHorizontal": 12,
"paddingTop": 6,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 30,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"height": 30,
"opacity": 1,
"width": 40,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={30}
bbWidth={30}
focusable={false}
height={30}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
vbHeight={100}
vbWidth={100}
width={30}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
pointerEvents="none"
style={
Object {
"alignItems": "baseline",
"flexDirection": "row",
"marginRight": "auto",
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
"fontSize": 21,
"fontWeight": "600",
},
]
}
>
Settings
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"opacity": 1,
"width": 36,
}
}
>
<
icon="plus"
size={18}
/>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={18}
bbWidth={18}
color={4278190080}
fill="none"
focusable={false}
height={18}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={3}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#000000",
"position": "relative",
"top": -1,
},
Object {
"flex": 0,
"height": 18,
"width": 18,
},
]
}
tintColor={4278190080}
vbHeight={24}
vbWidth={24}
width={18}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={3}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderRadius": 20,
"flexDirection": "row",
"height": 36,
"justifyContent": "center",
"marginLeft": 8,
"opacity": 1,
"width": 36,
}
}
>
<
icon="signal"
size={18}
style={
Array [
Object {
"color": "#000000",
},
]
}
/>
<
icon="x"
size={12}
style={
Object {
"backgroundColor": "#ffffff",
"color": "#d1106f",
"left": -4,
"position": "relative",
"top": 6,
}
}
/>
</View>
</View>
<View
style={
Array [
Object {
"marginTop": 10,
},
Object {
"paddingLeft": 10,
},
Object {
"paddingRight": 10,
},
]
}
>
<View
style={
Array [
Object {
"flexDirection": "row",
},
]
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#000000",
},
]
}
>
Signed in as
</Text>
<View
style={
Object {
"flex": 1,
}
}
/>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"opacity": 1,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#0085ff",
},
Object {
"fontWeight": "bold",
},
],
]
}
>
Sign out
</Text>
</View>
</View>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
>
<View
style={
Object {
"backgroundColor": "#ffffff",
"borderRadius": 4,
"flexDirection": "row",
"marginVertical": 6,
"paddingHorizontal": 10,
"paddingVertical": 10,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={40}
bbWidth={40}
focusable={false}
height={40}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 40,
"width": 40,
},
]
}
vbHeight={100}
vbWidth={100}
width={40}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
<View
style={
Array [
Object {
"marginLeft": 10,
},
]
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"fontSize": 18,
},
Object {
"color": "#000000",
},
],
]
}
>
</Text>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#645454",
},
],
]
}
>
@
</Text>
</View>
</View>
</View>
</View>
</View>
`;

23
__tests__/view/shell/mobile/Composer.test.tsx
View File

@ -1,23 +0,0 @@
import React from 'react'
import {Composer} from '../../../../src/view/shell/mobile/Composer'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
describe('Composer', () => {
const mockedProps = {
active: true,
winHeight: 844,
replyTo: {
author: {avatar: undefined, displayName: 'Alice', handle: 'alice.test'},
cid: 'bafyreieucrv36ylxrut4dr4jj264q2jj2vt2vfvhjfchgw3vua4gksvzia',
text: 'Captain, maybe we ought to turn on the searchlights now. No… that’s just what they’ll be expecting us to do.',
uri: 'at://did:plc:v3xz273ea2dzjpu2szsjzfue/app.bsky.feed.post/3jkcir3fhqv2u',
},
onPost: jest.fn(),
onClose: jest.fn(),
}
it('renders correctly', () => {
const tree = renderer.create(<Composer {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
})
})

67
__tests__/view/shell/mobile/Menu.test.tsx
View File

@ -1,15 +1,70 @@
import React from 'react'
import {Menu} from '../../../../src/view/shell/mobile/Menu'
import renderer from 'react-test-renderer'
// import {render} from '../../../../jest/test-utils'
import {cleanup, fireEvent, render} from '../../../../jest/test-utils'
import {
mockedNavigationStore,
mockedShellStore,
} from '../../../../__mocks__/state-mock'
describe('Menu', () => {
const onCloseMock = jest.fn()
const mockedProps = {
visible: true,
onClose: jest.fn(),
onClose: onCloseMock,
}
it('renders correctly', () => {
const tree = renderer.create(<Menu {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders menu', () => {
const {getByTestId} = render(<Menu {...mockedProps} />)
const menuView = getByTestId('menuView')
expect(menuView).toBeTruthy()
})
it('presses profile card button', () => {
const {getByTestId} = render(<Menu {...mockedProps} />)
const profileCardButton = getByTestId('profileCardButton')
fireEvent.press(profileCardButton)
expect(onCloseMock).toHaveBeenCalled()
expect(mockedNavigationStore.switchTo).toHaveBeenCalledWith(0, true)
})
it('presses search button', () => {
const {getByTestId} = render(<Menu {...mockedProps} />)
const searchBtn = getByTestId('searchBtn')
fireEvent.press(searchBtn)
expect(onCloseMock).toHaveBeenCalled()
expect(mockedNavigationStore.switchTo).toHaveBeenCalledWith(0, true)
expect(mockedNavigationStore.navigate).toHaveBeenCalledWith('/search')
})
it("presses notifications menu item' button", () => {
const {getAllByTestId} = render(<Menu {...mockedProps} />)
const menuItemButton = getAllByTestId('menuItemButton')
fireEvent.press(menuItemButton[1])
expect(onCloseMock).toHaveBeenCalled()
expect(mockedNavigationStore.switchTo).toHaveBeenCalledWith(1, true)
})
it('presses new scene button', () => {
const {getAllByTestId} = render(<Menu {...mockedProps} />)
const menuItemButton = getAllByTestId('menuItemButton')
fireEvent.press(menuItemButton[3])
expect(onCloseMock).toHaveBeenCalled()
expect(mockedShellStore.openModal).toHaveBeenCalled()
})
})

96
__tests__/view/shell/mobile/TabsSelector.test.tsx
View File

@ -1,17 +1,99 @@
import React from 'react'
import {Animated} from 'react-native'
import renderer from 'react-test-renderer'
import {Animated, Share} from 'react-native'
import {TabsSelector} from '../../../../src/view/shell/mobile/TabsSelector'
// import {render} from '../../../../jest/test-utils'
import {cleanup, fireEvent, render} from '../../../../jest/test-utils'
import {mockedNavigationStore} from '../../../../__mocks__/state-mock'
describe('TabsSelector', () => {
const onCloseMock = jest.fn()
const mockedProps = {
active: true,
tabMenuInterp: new Animated.Value(0),
onClose: jest.fn(),
onClose: onCloseMock,
}
it('renders correctly', () => {
const tree = renderer.create(<TabsSelector {...mockedProps} />).toJSON()
expect(tree).toMatchSnapshot()
afterAll(() => {
jest.clearAllMocks()
cleanup()
})
it('renders tabs selector', () => {
const {getByTestId} = render(<TabsSelector {...mockedProps} />)
const tabsSelectorView = getByTestId('tabsSelectorView')
expect(tabsSelectorView).toBeTruthy()
})
it('renders nothing if inactive', () => {
const {getByTestId} = render(
<TabsSelector {...{...mockedProps, active: false}} />,
)
const emptyView = getByTestId('emptyView')
expect(emptyView).toBeTruthy()
})
it('presses share button', () => {
const shareSpy = jest.spyOn(Share, 'share')
const {getByTestId} = render(<TabsSelector {...mockedProps} />)
const shareButton = getByTestId('shareButton')
fireEvent.press(shareButton)
expect(onCloseMock).toHaveBeenCalled()
expect(shareSpy).toHaveBeenCalledWith({url: 'https://bsky.app/'})
})
it('presses clone button', () => {
const {getByTestId} = render(<TabsSelector {...mockedProps} />)
const cloneButton = getByTestId('cloneButton')
fireEvent.press(cloneButton)
expect(onCloseMock).toHaveBeenCalled()
expect(mockedNavigationStore.newTab).toHaveBeenCalled()
})
it('presses new tab button', () => {
const {getByTestId} = render(<TabsSelector {...mockedProps} />)
const newTabButton = getByTestId('newTabButton')
fireEvent.press(newTabButton)
expect(onCloseMock).toHaveBeenCalled()
expect(mockedNavigationStore.newTab).toHaveBeenCalledWith('/')
})
it('presses change tab button', () => {
const {getAllByTestId} = render(<TabsSelector {...mockedProps} />)
const changeTabButton = getAllByTestId('changeTabButton')
fireEvent.press(changeTabButton[0])
expect(onCloseMock).toHaveBeenCalled()
expect(mockedNavigationStore.newTab).toHaveBeenCalledWith('/')
})
it('presses close tab button', () => {
const {getAllByTestId} = render(<TabsSelector {...mockedProps} />)
const closeTabButton = getAllByTestId('closeTabButton')
fireEvent.press(closeTabButton[0])
expect(onCloseMock).toHaveBeenCalled()
expect(mockedNavigationStore.setActiveTab).toHaveBeenCalledWith(0)
})
it('presses swipes to close the tab', () => {
const {getByTestId} = render(<TabsSelector {...mockedProps} />)
const tabsSwipable = getByTestId('tabsSwipable')
fireEvent(tabsSwipable, 'swipeableRightOpen')
expect(onCloseMock).toHaveBeenCalled()
expect(mockedNavigationStore.setActiveTab).toHaveBeenCalledWith(0)
})
})

659
__tests__/view/shell/mobile/__snapshots__/Composer.test.tsx.snap
View File

@ -1,659 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Composer renders correctly 1`] = `
<View
collapsable={false}
style={
Object {
"backgroundColor": "#fff",
"bottom": 0,
"paddingTop": 24,
"position": "absolute",
"top": 0,
"transform": Array [
Object {
"translateY": 844,
},
],
"width": "100%",
}
}
>
<View
onLayout={[Function]}
style={
Array [
Object {
"backgroundColor": "#fff",
"flex": 1,
"flexDirection": "column",
"height": "100%",
"padding": 15,
"paddingBottom": 0,
},
Object {
"paddingBottom": 0,
},
]
}
>
<RCTSafeAreaView
emulateUnlessSupported={true}
style={
Object {
"flex": 1,
}
}
>
<View
style={
Object {
"alignItems": "center",
"flexDirection": "row",
"height": 55,
"paddingBottom": 10,
"paddingHorizontal": 5,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"opacity": 1,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#0085ff",
},
Object {
"fontSize": 18,
},
],
]
}
>
Cancel
</Text>
</View>
<View
style={
Object {
"flex": 1,
}
}
/>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"opacity": 1,
}
}
>
<BVLinearGradient
colors={
Array [
4292542719,
4294901882,
]
}
endPoint={
Object {
"x": 1,
"y": 1,
}
}
locations={null}
startPoint={
Object {
"x": 0,
"y": 0,
}
}
style={
Object {
"borderRadius": 20,
"paddingHorizontal": 20,
"paddingVertical": 6,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#ffffff",
},
Object {
"fontSize": 16,
},
Object {
"fontWeight": "bold",
},
],
]
}
>
Reply
</Text>
</BVLinearGradient>
</View>
</View>
<RCTScrollView
style={
Object {
"flex": 1,
}
}
>
<View>
<View
style={
Object {
"borderTopColor": "#e4e2e2",
"borderTopWidth": 1,
"flexDirection": "row",
"paddingBottom": 16,
"paddingTop": 16,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={50}
bbWidth={50}
focusable={false}
height={50}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 50,
"width": 50,
},
]
}
vbHeight={100}
vbWidth={100}
width={50}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-16742913,
1,
-14631929,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="A"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
<View
style={
Object {
"flex": 1,
"paddingLeft": 13,
"paddingRight": 8,
}
}
>
<Text
onLongPress={[Function]}
onPress={[Function]}
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"fontSize": 16,
},
Object {
"fontWeight": "bold",
},
Object {
"color": "#000000",
},
],
]
}
>
Alice
</Text>
<Text
numberOfLines={6}
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"fontSize": 16,
},
Object {
"lineHeight": 20.8,
},
Object {
"color": "#000000",
},
],
]
}
>
Captain, maybe we ought to turn on the searchlights now. No… that’s just what they’ll be expecting us to do.
</Text>
</View>
</View>
<View
style={
Array [
Object {
"borderTopColor": "#e4e2e2",
"borderTopWidth": 1,
"flexDirection": "row",
"paddingTop": 16,
},
Object {
"flex": 1,
},
]
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={50}
bbWidth={50}
focusable={false}
height={50}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 50,
"width": 50,
},
]
}
vbHeight={100}
vbWidth={100}
width={50}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
<TextInput
multiline={true}
onChangeText={[Function]}
placeholder="Write your reply"
placeholderTextColor="#968d8d"
scrollEnabled={true}
style={
Object {
"alignSelf": "flex-start",
"color": "#000000",
"flex": 1,
"fontSize": 18,
"marginLeft": 8,
"padding": 5,
}
}
/>
</View>
</View>
</RCTScrollView>
<View
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderTopColor": "#e4e2e2",
"borderTopWidth": 1,
"flexDirection": "row",
"paddingRight": 5,
"paddingVertical": 10,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
hitSlop={
Object {
"bottom": 10,
"left": 10,
"right": 10,
"top": 10,
}
}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"opacity": 1,
"paddingLeft": 5,
}
}
>
<
icon={
Array [
"far",
"image",
]
}
size={24}
style={
Object {
"color": "#0085ff",
}
}
/>
</View>
<View
style={
Object {
"flex": 1,
}
}
/>
<Text
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"marginRight": 10,
},
Object {
"color": undefined,
},
],
]
}
>
256
</Text>
<View>
<View
indeterminateAnimationDuration={1000}
style={
Array [
Object {
"backgroundColor": "transparent",
"overflow": "hidden",
},
undefined,
]
}
>
<RNSVGSvgView
bbHeight={30}
bbWidth={30}
collapsable={false}
focusable={false}
height={30}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
width={30}
>
<RNSVGGroup>
<RNSVGPath
d="M15 2.5
A12.5 12.5 0 0 1 15 2.5"
propList={
Array [
"stroke",
"strokeWidth",
"strokeLinecap",
]
}
stroke={4278221567}
strokeLinecap={0}
strokeWidth={3}
/>
<RNSVGPath
d="M15 0.5
a14.5 14.5 0 0 1 0 29
a14.5 14.5 0 0 1 0 -29"
propList={
Array [
"stroke",
"strokeWidth",
"strokeLinecap",
]
}
stroke={4293190370}
strokeLinecap={0}
strokeWidth={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
</View>
</View>
<View
collapsable={false}
style={
Object {
"backgroundColor": "#ffffff",
"borderTopColor": "#e4e2e2",
"borderTopWidth": 1,
"bottom": 0,
"left": 0,
"position": "absolute",
"right": 0,
"top": 1334,
}
}
/>
</RCTSafeAreaView>
</View>
</View>
`;

837
__tests__/view/shell/mobile/__snapshots__/Menu.test.tsx.snap
View File

@ -1,837 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Menu renders correctly 1`] = `
<View
style={
Object {
"backgroundColor": "#ffffff",
"flex": 1,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"flexDirection": "row",
"margin": 10,
"marginBottom": 6,
"opacity": 1,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={60}
bbWidth={60}
focusable={false}
height={60}
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 60,
"width": 60,
},
]
}
vbHeight={100}
vbWidth={100}
width={60}
>
<RNSVGGroup>
<RNSVGDefs>
<RNSVGLinearGradient
gradient={
Array [
0,
-1292135,
1,
-2424577,
]
}
gradientTransform={null}
gradientUnits={0}
name="grad"
x1="0"
x2="1"
y1="0"
y2="1"
/>
</RNSVGDefs>
<RNSVGCircle
cx="50"
cy="50"
fill={
Array [
1,
"grad",
]
}
propList={
Array [
"fill",
]
}
r="50"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={4294967295}
font={
Object {
"fontSize": "50",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
]
}
rotate={Array []}
x={
Array [
"50",
]
}
y={
Array [
"67",
]
}
>
<RNSVGTSpan
content="X"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
<View
style={
Object {
"flex": 1,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#2D2626",
"fontSize": 24,
"fontWeight": "bold",
"marginLeft": 12,
},
]
}
>
</Text>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#423737",
"fontSize": 18,
"marginLeft": 12,
},
]
}
>
</Text>
</View>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"backgroundColor": "#f8f3f3",
"borderRadius": 8,
"flexDirection": "row",
"margin": 10,
"marginBottom": 0,
"opacity": 1,
"paddingHorizontal": 12,
"paddingVertical": 10,
}
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight={25}
bbWidth={25}
color={4284765268}
fill="none"
focusable={false}
height={25}
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={2}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#645454",
},
Object {
"flex": 0,
"height": 25,
"width": 25,
},
]
}
tintColor={4284765268}
vbHeight={24}
vbWidth={24}
width={25}
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={2}
>
<RNSVGPath
d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#423737",
"fontSize": 19,
"marginLeft": 8,
},
]
}
>
Search
</Text>
</View>
<View
style={
Object {
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"paddingBottom": 10,
"paddingHorizontal": 10,
"paddingTop": 10,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"flexDirection": "row",
"opacity": 1,
"paddingHorizontal": 6,
"paddingVertical": 8,
}
}
>
<View
style={
Array [
Object {
"alignItems": "center",
"height": 36,
"justifyContent": "center",
"marginRight": 12,
"width": 36,
},
]
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight="26"
bbWidth="26"
color={4282529591}
focusable={false}
height="26"
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#423737",
},
Object {
"flex": 0,
"height": 26,
"width": 26,
},
]
}
tintColor={4282529591}
vbHeight={48}
vbWidth={48}
width="26"
>
<RNSVGGroup
propList={
Array [
"stroke",
]
}
stroke={
Array [
2,
]
}
>
<RNSVGPath
d="M 23.951 2 C 23.631 2.011 23.323 2.124 23.072 2.322 L 8.859 13.52 C 7.055 14.941 6 17.114 6 19.41 L 6 38.5 C 6 39.864 7.136 41 8.5 41 L 18.5 41 C 19.864 41 21 39.864 21 38.5 L 21 28.5 C 21 28.205 21.205 28 21.5 28 L 26.5 28 C 26.795 28 27 28.205 27 28.5 L 27 38.5 C 27 39.864 28.136 41 29.5 41 L 39.5 41 C 40.864 41 42 39.864 42 38.5 L 42 19.41 C 42 17.114 40.945 14.941 39.141 13.52 L 24.928 2.322 C 24.65 2.103 24.304 1.989 23.951 2 Z"
propList={
Array [
"strokeWidth",
]
}
strokeWidth={4}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<Text
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#2D2626",
"fontSize": 19,
},
undefined,
],
]
}
>
Home
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"flexDirection": "row",
"opacity": 1,
"paddingHorizontal": 6,
"paddingVertical": 8,
}
}
>
<View
style={
Array [
Object {
"alignItems": "center",
"height": 36,
"justifyContent": "center",
"marginRight": 12,
"width": 36,
},
]
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight="28"
bbWidth="28"
color={4282529591}
fill="none"
focusable={false}
height="28"
meetOrSlice={0}
minX={0}
minY={0}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#423737",
},
Object {
"flex": 0,
"height": 28,
"width": 28,
},
]
}
tintColor={4282529591}
vbHeight={24}
vbWidth={24}
width="28"
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
]
}
>
<RNSVGPath
d="M0 0h24v24H0z"
fill={null}
propList={
Array [
"fill",
]
}
/>
<RNSVGPath
d="M20 17h2v2H2v-2h2v-7a8 8 0 1 1 16 0v7zm-2 0v-7a6 6 0 1 0-12 0v7h12zm-9 4h6v2H9v-2z"
fill={
Array [
2,
]
}
propList={
Array [
"fill",
]
}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<Text
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#2D2626",
"fontSize": 19,
},
undefined,
],
]
}
>
Notifications
</Text>
</View>
</View>
<View
style={
Object {
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"paddingBottom": 10,
"paddingHorizontal": 10,
"paddingTop": 10,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"fontSize": 16,
"fontWeight": "bold",
"paddingHorizontal": 4,
"paddingVertical": 8,
},
]
}
>
Scenes
</Text>
</View>
<View
style={
Object {
"borderBottomColor": "#f8f3f3",
"borderBottomWidth": 1,
"paddingBottom": 10,
"paddingHorizontal": 10,
"paddingTop": 10,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"flexDirection": "row",
"opacity": 1,
"paddingHorizontal": 6,
"paddingVertical": 8,
}
}
>
<View
style={
Array [
Object {
"alignItems": "center",
"height": 36,
"justifyContent": "center",
"marginRight": 12,
"width": 36,
},
]
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight="30"
bbWidth="30"
color={4282529591}
fill="none"
focusable={false}
height="30"
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={2}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#423737",
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
tintColor={4282529591}
vbHeight={24}
vbWidth={24}
width="30"
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={2}
>
<RNSVGPath
d="M18 18.72a9.094 9.094 0 003.741-.479 3 3 0 00-4.682-2.72m.94 3.198l.001.031c0 .225-.012.447-.037.666A11.944 11.944 0 0112 21c-2.17 0-4.207-.576-5.963-1.584A6.062 6.062 0 016 18.719m12 0a5.971 5.971 0 00-.941-3.197m0 0A5.995 5.995 0 0012 12.75a5.995 5.995 0 00-5.058 2.772m0 0a3 3 0 00-4.681 2.72 8.986 8.986 0 003.74.477m.94-3.197a5.971 5.971 0 00-.94 3.197M15 6.75a3 3 0 11-6 0 3 3 0 016 0zm6 3a2.25 2.25 0 11-4.5 0 2.25 2.25 0 014.5 0zm-13.5 0a2.25 2.25 0 11-4.5 0 2.25 2.25 0 014.5 0z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<Text
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#2D2626",
"fontSize": 19,
},
undefined,
],
]
}
>
Create a scene
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"flexDirection": "row",
"opacity": 1,
"paddingHorizontal": 6,
"paddingVertical": 8,
}
}
>
<View
style={
Array [
Object {
"alignItems": "center",
"height": 36,
"justifyContent": "center",
"marginRight": 12,
"width": 36,
},
]
}
>
<RNSVGSvgView
align="xMidYMid"
bbHeight="30"
bbWidth="30"
color={4282529591}
fill="none"
focusable={false}
height="30"
meetOrSlice={0}
minX={0}
minY={0}
stroke="currentColor"
strokeWidth={2}
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"color": "#423737",
},
Object {
"flex": 0,
"height": 30,
"width": 30,
},
]
}
tintColor={4282529591}
vbHeight={24}
vbWidth={24}
width="30"
>
<RNSVGGroup
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
stroke={
Array [
2,
]
}
strokeWidth={2}
>
<RNSVGPath
d="M9.594 3.94c.09-.542.56-.94 1.11-.94h2.593c.55 0 1.02.398 1.11.94l.213 1.281c.063.374.313.686.645.87.074.04.147.083.22.127.324.196.72.257 1.075.124l1.217-.456a1.125 1.125 0 011.37.49l1.296 2.247a1.125 1.125 0 01-.26 1.431l-1.003.827c-.293.24-.438.613-.431.992a6.759 6.759 0 010 .255c-.007.378.138.75.43.99l1.005.828c.424.35.534.954.26 1.43l-1.298 2.247a1.125 1.125 0 01-1.369.491l-1.217-.456c-.355-.133-.75-.072-1.076.124a6.57 6.57 0 01-.22.128c-.331.183-.581.495-.644.869l-.213 1.28c-.09.543-.56.941-1.11.941h-2.594c-.55 0-1.02-.398-1.11-.94l-.213-1.281c-.062-.374-.312-.686-.644-.87a6.52 6.52 0 01-.22-.127c-.325-.196-.72-.257-1.076-.124l-1.217.456a1.125 1.125 0 01-1.369-.49l-1.297-2.247a1.125 1.125 0 01.26-1.431l1.004-.827c.292-.24.437-.613.43-.992a6.932 6.932 0 010-.255c.007-.378-.138-.75-.43-.99l-1.004-.828a1.125 1.125 0 01-.26-1.43l1.297-2.247a1.125 1.125 0 011.37-.491l1.216.456c.356.133.751.072 1.076-.124.072-.044.146-.087.22-.128.332-.183.582-.495.644-.869l.214-1.281z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
<RNSVGPath
d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"
propList={
Array [
"strokeLinecap",
"strokeLinejoin",
]
}
strokeLinecap={1}
strokeLinejoin={1}
/>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<Text
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"color": "#2D2626",
"fontSize": 19,
},
undefined,
],
]
}
>
Settings
</Text>
</View>
</View>
<View
style={
Object {
"paddingHorizontal": 14,
"paddingVertical": 18,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#968d8d",
},
]
}
>
Build version
(
)
</Text>
</View>
</View>
`;

651
__tests__/view/shell/mobile/__snapshots__/TabsSelector.test.tsx.snap
View File

@ -1,651 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`TabsSelector renders correctly 1`] = `
<View
collapsable={false}
style={
Object {
"backgroundColor": "#fff",
"borderTopColor": "#e4e2e2",
"borderTopWidth": 1,
"bottom": 55,
"height": 320,
"opacity": 1,
"position": "absolute",
"transform": Array [
Object {
"translateY": 320,
},
],
"width": "100%",
}
}
>
<View
onLayout={[Function]}
>
<View
style={
Array [
Object {
"padding": 10,
},
Object {
"borderBottomColor": "#e4e2e2",
"borderBottomWidth": 1,
},
]
}
>
<View
style={
Object {
"flexDirection": "row",
"paddingTop": 2,
}
}
>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Array [
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 4,
"flex": 1,
"flexDirection": "row",
"justifyContent": "center",
"marginRight": 5,
"paddingLeft": 12,
"paddingRight": 16,
"paddingVertical": 10,
},
]
}
>
<View
style={
Object {
"marginRight": 8,
}
}
>
<
icon="share"
size={16}
/>
</View>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"fontSize": 16,
"fontWeight": "500",
},
]
}
>
Share
</Text>
</View>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Array [
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 4,
"flex": 1,
"flexDirection": "row",
"justifyContent": "center",
"marginRight": 5,
"paddingLeft": 12,
"paddingRight": 16,
"paddingVertical": 10,
},
]
}
>
<View
style={
Object {
"marginRight": 8,
}
}
>
<
icon={
Array [
"far",
"clone",
]
}
size={16}
/>
</View>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"fontSize": 16,
"fontWeight": "500",
},
]
}
>
Clone tab
</Text>
</View>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Array [
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderRadius": 4,
"flex": 1,
"flexDirection": "row",
"justifyContent": "center",
"marginRight": 5,
"paddingLeft": 12,
"paddingRight": 16,
"paddingVertical": 10,
},
]
}
>
<View
style={
Object {
"marginRight": 8,
}
}
>
<
icon="plus"
size={16}
/>
</View>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"fontSize": 16,
"fontWeight": "500",
},
]
}
>
New tab
</Text>
</View>
</View>
</View>
<View
style={
Array [
Object {
"padding": 10,
},
Object {
"borderBottomColor": "#e4e2e2",
"borderBottomWidth": 1,
},
Object {
"backgroundColor": "#f8f3f3",
},
]
}
>
<RCTScrollView
style={
Object {
"height": 240,
}
}
>
<View>
<View
collapsable={false}
forwardedRef={[Function]}
handlerTag={1}
handlerType="PanGestureHandler"
onGestureHandlerEvent={[Function]}
onGestureHandlerStateChange={[Function]}
onLayout={[Function]}
style={
Object {
"overflow": "hidden",
}
}
>
<View
collapsable={false}
style={
Object {
"bottom": 0,
"flexDirection": "row",
"left": 0,
"position": "absolute",
"right": 0,
"top": 0,
"transform": Array [
Object {
"translateX": -10000,
},
],
}
}
>
<View
style={
Array [
Object {
"padding": 2,
},
]
}
/>
<View
onLayout={[Function]}
/>
</View>
<View
collapsable={false}
style={
Object {
"bottom": 0,
"flexDirection": "row-reverse",
"left": 0,
"position": "absolute",
"right": 0,
"top": 0,
"transform": Array [
Object {
"translateX": -10000,
},
],
}
}
>
<View
style={
Array [
Object {
"padding": 2,
},
]
}
/>
<View
onLayout={[Function]}
/>
</View>
<View
collapsable={false}
forwardedRef={[Function]}
handlerTag={2}
handlerType="TapGestureHandler"
onGestureHandlerEvent={[Function]}
onGestureHandlerStateChange={[Function]}
pointerEvents="auto"
style={
Object {
"transform": Array [
Object {
"translateX": -0,
},
],
}
}
>
<View
collapsable={false}
style={
Object {
"height": 46,
"overflow": "hidden",
}
}
>
<View
collapsable={false}
forwardedRef={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#ffffff",
"borderColor": "#000000",
"borderRadius": 4,
"borderWidth": 1,
"flexDirection": "row",
"height": 42,
}
}
>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"flex": 1,
"flexDirection": "row",
"paddingLeft": 12,
"paddingVertical": 12,
}
}
>
<View
style={Object {}}
>
<
icon="house"
size={20}
/>
</View>
<Text
ellipsizeMode="tail"
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"flex": 1,
"fontSize": 16,
"paddingHorizontal": 10,
},
Object {
"fontWeight": "500",
},
],
]
}
suppressHighlighting={true}
>
/
</Text>
</View>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"paddingRight": 16,
"paddingVertical": 16,
}
}
>
<
icon="x"
size={14}
style={
Object {
"color": "#655",
}
}
/>
</View>
</View>
</View>
</View>
</View>
<View
collapsable={false}
forwardedRef={[Function]}
handlerTag={3}
handlerType="PanGestureHandler"
onGestureHandlerEvent={[Function]}
onGestureHandlerStateChange={[Function]}
onLayout={[Function]}
style={
Object {
"overflow": "hidden",
}
}
>
<View
collapsable={false}
style={
Object {
"bottom": 0,
"flexDirection": "row",
"left": 0,
"position": "absolute",
"right": 0,
"top": 0,
"transform": Array [
Object {
"translateX": -10000,
},
],
}
}
>
<View
style={
Array [
Object {
"padding": 2,
},
]
}
/>
<View
onLayout={[Function]}
/>
</View>
<View
collapsable={false}
style={
Object {
"bottom": 0,
"flexDirection": "row-reverse",
"left": 0,
"position": "absolute",
"right": 0,
"top": 0,
"transform": Array [
Object {
"translateX": -10000,
},
],
}
}
>
<View
style={
Array [
Object {
"padding": 2,
},
]
}
/>
<View
onLayout={[Function]}
/>
</View>
<View
collapsable={false}
forwardedRef={[Function]}
handlerTag={4}
handlerType="TapGestureHandler"
onGestureHandlerEvent={[Function]}
onGestureHandlerStateChange={[Function]}
pointerEvents="auto"
style={
Object {
"transform": Array [
Object {
"translateX": -0,
},
],
}
}
>
<View
collapsable={false}
style={
Object {
"height": 46,
"overflow": "hidden",
}
}
>
<View
collapsable={false}
forwardedRef={[Function]}
style={
Object {
"alignItems": "center",
"backgroundColor": "#f8f3f3",
"borderColor": "#968d8d",
"borderRadius": 4,
"borderWidth": 1,
"flexDirection": "row",
"height": 42,
}
}
>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"alignItems": "center",
"flex": 1,
"flexDirection": "row",
"paddingLeft": 12,
"paddingVertical": 12,
}
}
>
<View
style={Object {}}
>
<
icon="bell"
size={20}
/>
</View>
<Text
ellipsizeMode="tail"
numberOfLines={1}
style={
Array [
Object {
"color": "#000000",
},
Array [
Object {
"flex": 1,
"fontSize": 16,
"paddingHorizontal": 10,
},
false,
],
]
}
suppressHighlighting={true}
>
/notifications
</Text>
</View>
<View
accessible={true}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"paddingRight": 16,
"paddingVertical": 16,
}
}
>
<
icon="x"
size={14}
style={
Object {
"color": "#655",
}
}
/>
</View>
</View>
</View>
</View>
</View>
</View>
</RCTScrollView>
</View>
</View>
</View>
`;

421
__tests__/view/shell/mobile/__snapshots__/index.test.tsx.snap
View File

@ -1,421 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`MobileShell renders correctly 1`] = `
<BVLinearGradient
colors={
Array [
4278222079,
4278238463,
]
}
endPoint={
Object {
"x": 0,
"y": 1,
}
}
locations={null}
startPoint={
Object {
"x": 0,
"y": 0.8,
}
}
style={
Object {
"flex": 1,
"height": "100%",
}
}
>
<RCTSafeAreaView
emulateUnlessSupported={true}
style={
Object {
"flex": 1,
}
}
>
<View
style={
Object {
"flex": 1,
}
}
>
<View
style={
Object {
"flex": 2,
"justifyContent": "center",
}
}
>
<View
style={
Object {
"flexDirection": "row",
"justifyContent": "center",
}
}
>
<RNSVGSvgView
bbHeight="100"
bbWidth="100"
focusable={false}
height="100"
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"flex": 0,
"height": 100,
"width": 100,
},
]
}
width="100"
>
<RNSVGGroup>
<RNSVGCircle
cx="50"
cy="50"
fill={null}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
r="46"
stroke={4294967295}
strokeWidth={2}
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth={1}
x1="30"
x2="30"
y1="0"
y2="100"
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth={1}
x1="74"
x2="74"
y1="0"
y2="100"
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth={1}
x1="0"
x2="100"
y1="22"
y2="22"
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth={1}
x1="0"
x2="100"
y1="74"
y2="74"
/>
<RNSVGText
content={null}
dx={Array []}
dy={Array []}
fill={null}
font={
Object {
"fontSize": "60",
"fontWeight": "bold",
"textAnchor": "middle",
}
}
propList={
Array [
"fill",
"stroke",
"strokeWidth",
]
}
rotate={Array []}
stroke={4294967295}
strokeWidth={2}
x={
Array [
"52",
]
}
y={
Array [
"70",
]
}
>
<RNSVGTSpan
content="B"
dx={Array []}
dy={Array []}
font={Object {}}
rotate={Array []}
x={Array []}
y={Array []}
/>
</RNSVGText>
</RNSVGGroup>
</RNSVGSvgView>
</View>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 68,
"fontWeight": "bold",
"textAlign": "center",
},
]
}
>
Bluesky
</Text>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 18,
"textAlign": "center",
},
]
}
>
[ private beta ]
</Text>
</View>
<View
style={
Object {
"flex": 1,
}
}
>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"backgroundColor": "#0085ff",
"borderColor": "#ffffff",
"borderRadius": 10,
"borderWidth": 1,
"marginBottom": 20,
"marginHorizontal": 20,
"opacity": 1,
"paddingVertical": 16,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 18,
"fontWeight": "bold",
"textAlign": "center",
},
]
}
>
Create a new account
</Text>
</View>
<View
style={
Object {
"marginBottom": 20,
}
}
>
<RNSVGSvgView
bbHeight="1"
bbWidth={750}
focusable={false}
height="1"
style={
Array [
Object {
"backgroundColor": "transparent",
"borderWidth": 0,
},
Object {
"position": "absolute",
"top": 10,
},
Object {
"flex": 0,
"height": 1,
"width": 750,
},
]
}
width={750}
>
<RNSVGGroup>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth="1"
x1="30"
x2={355}
y1="0"
y2="0"
/>
<RNSVGLine
propList={
Array [
"stroke",
"strokeWidth",
]
}
stroke={4294967295}
strokeWidth="1"
x1={395}
x2={720}
y1="0"
y2="0"
/>
</RNSVGGroup>
</RNSVGSvgView>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 16,
"textAlign": "center",
},
]
}
>
or
</Text>
</View>
<View
accessible={true}
collapsable={false}
focusable={true}
onClick={[Function]}
onResponderGrant={[Function]}
onResponderMove={[Function]}
onResponderRelease={[Function]}
onResponderTerminate={[Function]}
onResponderTerminationRequest={[Function]}
onStartShouldSetResponder={[Function]}
style={
Object {
"backgroundColor": "#0085ff",
"borderColor": "#ffffff",
"borderRadius": 10,
"borderWidth": 1,
"marginBottom": 20,
"marginHorizontal": 20,
"opacity": 1,
"paddingVertical": 16,
}
}
>
<Text
style={
Array [
Object {
"color": "#000000",
},
Object {
"color": "#ffffff",
"fontSize": 18,
"fontWeight": "bold",
"textAlign": "center",
},
]
}
>
Sign in
</Text>
</View>
</View>
</View>
</RCTSafeAreaView>
<View
enablePanDownToClose={true}
index={-1}
keyboardBehavior="fillParent"
onChange={[Function]}
snapPoints={
Array [
"10%",
]
}
>
<View />
</View>
</BVLinearGradient>
`;

18
__tests__/view/shell/mobile/index.test.tsx
View File

@ -1,18 +0,0 @@
import React from 'react'
import {MobileShell} from '../../../../src/view/shell/mobile'
import renderer from 'react-test-renderer'
import {SafeAreaProvider} from 'react-native-safe-area-context'
// import {render} from '../../../../jest/test-utils'
describe('MobileShell', () => {
it('renders correctly', () => {
const tree = renderer
.create(
<SafeAreaProvider>
<MobileShell />
</SafeAreaProvider>,
)
.toJSON()
expect(tree).toMatchSnapshot()
})
})

68
ios/app.xcodeproj/project.pbxproj
View File

@ -11,9 +11,9 @@
13B07FBC1A68108700A75B9A /* AppDelegate.mm in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB01A68108700A75B9A /* AppDelegate.mm */; };
13B07FBF1A68108700A75B9A /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB51A68108700A75B9A /* Images.xcassets */; };
13B07FC11A68108700A75B9A /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB71A68108700A75B9A /* main.m */; };
56F0250941FE75DA8CF8094A /* libPods-app-appTests.a in Frameworks */ = {isa = PBXBuildFile; fileRef = F5D2424078D205E2F98F0707 /* libPods-app-appTests.a */; };
5698CA584FD738B2091BD18F /* libPods-app-appTests.a in Frameworks */ = {isa = PBXBuildFile; fileRef = C0C7BDE7769B84011D3747DC /* libPods-app-appTests.a */; };
67BF1AE6AABFC881715B2D6A /* libPods-app.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 8789F612EDA2C48C6064ADD6 /* libPods-app.a */; };
81AB9BB82411601600AC10FF /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */; };
BFADB63545C91424F7C8293A /* libPods-app.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 9C668306DD1C0A63684EDCB0 /* libPods-app.a */; };
E4BBD590292C1F5200296224 /* app.entitlements in Resources */ = {isa = PBXBuildFile; fileRef = E4437C9E28581FA7006DA9E7 /* app.entitlements */; };
/* End PBXBuildFile section */
@ -37,15 +37,15 @@
13B07FB51A68108700A75B9A /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Images.xcassets; path = app/Images.xcassets; sourceTree = "<group>"; };
13B07FB61A68108700A75B9A /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = app/Info.plist; sourceTree = "<group>"; };
13B07FB71A68108700A75B9A /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = main.m; path = app/main.m; sourceTree = "<group>"; };
3D3D4D80CD734363E3EADE03 /* Pods-app.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-app.release.xcconfig"; path = "Target Support Files/Pods-app/Pods-app.release.xcconfig"; sourceTree = "<group>"; };
65D2EDDD9D88DA37994C7743 /* Pods-app-appTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-app-appTests.debug.xcconfig"; path = "Target Support Files/Pods-app-appTests/Pods-app-appTests.debug.xcconfig"; sourceTree = "<group>"; };
53DBA218C184B95B107AC33E /* Pods-app.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-app.release.xcconfig"; path = "Target Support Files/Pods-app/Pods-app.release.xcconfig"; sourceTree = "<group>"; };
81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.storyboard; name = LaunchScreen.storyboard; path = app/LaunchScreen.storyboard; sourceTree = "<group>"; };
9C668306DD1C0A63684EDCB0 /* libPods-app.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-app.a"; sourceTree = BUILT_PRODUCTS_DIR; };
A79BD0E1A3F5B868AD4F5D68 /* Pods-app.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-app.debug.xcconfig"; path = "Target Support Files/Pods-app/Pods-app.debug.xcconfig"; sourceTree = "<group>"; };
AA0AD1B60CF7C90FFDB948B9 /* Pods-app-appTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-app-appTests.release.xcconfig"; path = "Target Support Files/Pods-app-appTests/Pods-app-appTests.release.xcconfig"; sourceTree = "<group>"; };
8789F612EDA2C48C6064ADD6 /* libPods-app.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-app.a"; sourceTree = BUILT_PRODUCTS_DIR; };
8BB4EDB104E125B8A1913E74 /* Pods-app.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-app.debug.xcconfig"; path = "Target Support Files/Pods-app/Pods-app.debug.xcconfig"; sourceTree = "<group>"; };
A8E093A0B5DA947150924A68 /* Pods-app-appTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-app-appTests.release.xcconfig"; path = "Target Support Files/Pods-app-appTests/Pods-app-appTests.release.xcconfig"; sourceTree = "<group>"; };
C01FB6762BC17DADC0319338 /* Pods-app-appTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-app-appTests.debug.xcconfig"; path = "Target Support Files/Pods-app-appTests/Pods-app-appTests.debug.xcconfig"; sourceTree = "<group>"; };
C0C7BDE7769B84011D3747DC /* libPods-app-appTests.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-app-appTests.a"; sourceTree = BUILT_PRODUCTS_DIR; };
E4437C9E28581FA7006DA9E7 /* app.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; name = app.entitlements; path = app/app.entitlements; sourceTree = "<group>"; };
ED297162215061F000B7C4FE /* JavaScriptCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = JavaScriptCore.framework; path = System/Library/Frameworks/JavaScriptCore.framework; sourceTree = SDKROOT; };
F5D2424078D205E2F98F0707 /* libPods-app-appTests.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-app-appTests.a"; sourceTree = BUILT_PRODUCTS_DIR; };
/* End PBXFileReference section */
/* Begin PBXFrameworksBuildPhase section */
@ -53,7 +53,7 @@
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
56F0250941FE75DA8CF8094A /* libPods-app-appTests.a in Frameworks */,
5698CA584FD738B2091BD18F /* libPods-app-appTests.a in Frameworks */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@ -61,7 +61,7 @@
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
BFADB63545C91424F7C8293A /* libPods-app.a in Frameworks */,
67BF1AE6AABFC881715B2D6A /* libPods-app.a in Frameworks */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@ -103,8 +103,8 @@
isa = PBXGroup;
children = (
ED297162215061F000B7C4FE /* JavaScriptCore.framework */,
9C668306DD1C0A63684EDCB0 /* libPods-app.a */,
F5D2424078D205E2F98F0707 /* libPods-app-appTests.a */,
8789F612EDA2C48C6064ADD6 /* libPods-app.a */,
C0C7BDE7769B84011D3747DC /* libPods-app-appTests.a */,
);
name = Frameworks;
sourceTree = "<group>";
@ -143,10 +143,10 @@
BBD78D7AC51CEA395F1C20DB /* Pods */ = {
isa = PBXGroup;
children = (
A79BD0E1A3F5B868AD4F5D68 /* Pods-app.debug.xcconfig */,
3D3D4D80CD734363E3EADE03 /* Pods-app.release.xcconfig */,
65D2EDDD9D88DA37994C7743 /* Pods-app-appTests.debug.xcconfig */,
AA0AD1B60CF7C90FFDB948B9 /* Pods-app-appTests.release.xcconfig */,
8BB4EDB104E125B8A1913E74 /* Pods-app.debug.xcconfig */,
53DBA218C184B95B107AC33E /* Pods-app.release.xcconfig */,
C01FB6762BC17DADC0319338 /* Pods-app-appTests.debug.xcconfig */,
A8E093A0B5DA947150924A68 /* Pods-app-appTests.release.xcconfig */,
);
path = Pods;
sourceTree = "<group>";
@ -158,11 +158,11 @@
isa = PBXNativeTarget;
buildConfigurationList = 00E357021AD99517003FC87E /* Build configuration list for PBXNativeTarget "appTests" */;
buildPhases = (
A8646FFAA087C80271BB2CC6 /* [CP] Check Pods Manifest.lock */,
A6849EFFDCB214D4F4EAE972 /* [CP] Check Pods Manifest.lock */,
00E356EA1AD99517003FC87E /* Sources */,
00E356EB1AD99517003FC87E /* Frameworks */,
00E356EC1AD99517003FC87E /* Resources */,
8DC349844744C81F79F94A1E /* [CP] Copy Pods Resources */,
DFA0C2B14E2F369C4B2337CE /* [CP] Copy Pods Resources */,
);
buildRules = (
);
@ -178,13 +178,13 @@
isa = PBXNativeTarget;
buildConfigurationList = 13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "app" */;
buildPhases = (
AFA1F7779F8B1AF36C3A7914 /* [CP] Check Pods Manifest.lock */,
DDF15D430A078CE70E577FDA /* [CP] Check Pods Manifest.lock */,
FD10A7F022414F080027D42C /* Start Packager */,
13B07F871A680F5B00A75B9A /* Sources */,
13B07F8C1A680F5B00A75B9A /* Frameworks */,
13B07F8E1A680F5B00A75B9A /* Resources */,
00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */,
EEF3465D9B31EDDCEB2438EA /* [CP] Copy Pods Resources */,
45E56D79C207C80AF89FBAA2 /* [CP] Copy Pods Resources */,
);
buildRules = (
);
@ -266,24 +266,24 @@
shellPath = /bin/sh;
shellScript = "set -e\n\nexport NODE_BINARY=node\n../node_modules/react-native/scripts/react-native-xcode.sh\n";
};
8DC349844744C81F79F94A1E /* [CP] Copy Pods Resources */ = {
45E56D79C207C80AF89FBAA2 /* [CP] Copy Pods Resources */ = {
isa = PBXShellScriptBuildPhase;
buildActionMask = 2147483647;
files = (
);
inputFileListPaths = (
"${PODS_ROOT}/Target Support Files/Pods-app-appTests/Pods-app-appTests-resources-${CONFIGURATION}-input-files.xcfilelist",
"${PODS_ROOT}/Target Support Files/Pods-app/Pods-app-resources-${CONFIGURATION}-input-files.xcfilelist",
);
name = "[CP] Copy Pods Resources";
outputFileListPaths = (
"${PODS_ROOT}/Target Support Files/Pods-app-appTests/Pods-app-appTests-resources-${CONFIGURATION}-output-files.xcfilelist",
"${PODS_ROOT}/Target Support Files/Pods-app/Pods-app-resources-${CONFIGURATION}-output-files.xcfilelist",
);
runOnlyForDeploymentPostprocessing = 0;
shellPath = /bin/sh;
shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-app-appTests/Pods-app-appTests-resources.sh\"\n";
shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-app/Pods-app-resources.sh\"\n";
showEnvVarsInLog = 0;
};
A8646FFAA087C80271BB2CC6 /* [CP] Check Pods Manifest.lock */ = {
A6849EFFDCB214D4F4EAE972 /* [CP] Check Pods Manifest.lock */ = {
isa = PBXShellScriptBuildPhase;
buildActionMask = 2147483647;
files = (
@ -305,7 +305,7 @@
shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
showEnvVarsInLog = 0;
};
AFA1F7779F8B1AF36C3A7914 /* [CP] Check Pods Manifest.lock */ = {
DDF15D430A078CE70E577FDA /* [CP] Check Pods Manifest.lock */ = {
isa = PBXShellScriptBuildPhase;
buildActionMask = 2147483647;
files = (
@ -327,21 +327,21 @@
shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
showEnvVarsInLog = 0;
};
EEF3465D9B31EDDCEB2438EA /* [CP] Copy Pods Resources */ = {
DFA0C2B14E2F369C4B2337CE /* [CP] Copy Pods Resources */ = {
isa = PBXShellScriptBuildPhase;
buildActionMask = 2147483647;
files = (
);
inputFileListPaths = (
"${PODS_ROOT}/Target Support Files/Pods-app/Pods-app-resources-${CONFIGURATION}-input-files.xcfilelist",
"${PODS_ROOT}/Target Support Files/Pods-app-appTests/Pods-app-appTests-resources-${CONFIGURATION}-input-files.xcfilelist",
);
name = "[CP] Copy Pods Resources";
outputFileListPaths = (
"${PODS_ROOT}/Target Support Files/Pods-app/Pods-app-resources-${CONFIGURATION}-output-files.xcfilelist",
"${PODS_ROOT}/Target Support Files/Pods-app-appTests/Pods-app-appTests-resources-${CONFIGURATION}-output-files.xcfilelist",
);
runOnlyForDeploymentPostprocessing = 0;
shellPath = /bin/sh;
shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-app/Pods-app-resources.sh\"\n";
shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-app-appTests/Pods-app-appTests-resources.sh\"\n";
showEnvVarsInLog = 0;
};
FD10A7F022414F080027D42C /* Start Packager */ = {
@ -396,7 +396,7 @@
/* Begin XCBuildConfiguration section */
00E356F61AD99517003FC87E /* Debug */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 65D2EDDD9D88DA37994C7743 /* Pods-app-appTests.debug.xcconfig */;
baseConfigurationReference = C01FB6762BC17DADC0319338 /* Pods-app-appTests.debug.xcconfig */;
buildSettings = {
ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES;
BUNDLE_LOADER = "$(TEST_HOST)";
@ -424,7 +424,7 @@
};
00E356F71AD99517003FC87E /* Release */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = AA0AD1B60CF7C90FFDB948B9 /* Pods-app-appTests.release.xcconfig */;
baseConfigurationReference = A8E093A0B5DA947150924A68 /* Pods-app-appTests.release.xcconfig */;
buildSettings = {
ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES;
BUNDLE_LOADER = "$(TEST_HOST)";
@ -449,7 +449,7 @@
};
13B07F941A680F5B00A75B9A /* Debug */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = A79BD0E1A3F5B868AD4F5D68 /* Pods-app.debug.xcconfig */;
baseConfigurationReference = 8BB4EDB104E125B8A1913E74 /* Pods-app.debug.xcconfig */;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
CLANG_ENABLE_MODULES = YES;
@ -479,7 +479,7 @@
};
13B07F951A680F5B00A75B9A /* Release */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 3D3D4D80CD734363E3EADE03 /* Pods-app.release.xcconfig */;
baseConfigurationReference = 53DBA218C184B95B107AC33E /* Pods-app.release.xcconfig */;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
CLANG_ENABLE_MODULES = YES;

26
jest/jestSetup.js
View File

@ -1,17 +1,17 @@
import 'react-native-gesture-handler/jestSetup'
jest.mock('@react-native-async-storage/async-storage', () =>
require('@react-native-async-storage/async-storage/jest/async-storage-mock'),
)
jest.mock('react-native/Libraries/EventEmitter/NativeEventEmitter')
// Silence the warning: Animated: `useNativeDriver` is not supported
jest.mock('react-native/Libraries/Animated/NativeAnimatedHelper')
require('react-native-reanimated/lib/reanimated2/jestUtils').setUpTests()
jest.mock('@fortawesome/react-native-fontawesome', () => ({
FontAwesomeIcon: '',
}))
require('react-native-reanimated/lib/reanimated2/jestUtils').setUpTests()
// Silence the warning: Animated: `useNativeDriver` is not supported
jest.mock('react-native/Libraries/Animated/NativeAnimatedHelper')
jest.mock('react-native-safe-area-context', () => {
const inset = {top: 0, right: 0, bottom: 0, left: 0}
return {
@ -36,4 +36,18 @@ jest.mock('@gorhom/bottom-sheet', () => {
}
})
jest.useFakeTimers()
jest.mock('rn-fetch-blob', () => ({
config: jest.fn().mockReturnThis(),
cancel: jest.fn(),
fetch: jest.fn(),
}))
jest.mock('@bam.tech/react-native-image-resizer', () => ({
createResizedImage: jest.fn(),
}))
import {View as mockedView} from 'react-native'
jest.mock('react-native-tab-view', () => ({
...jest.requireActual('react-native-tab-view'),
TabView: mockedView,
}))

28
jest/test-utils.tsx
View File

@ -1,29 +1,27 @@
import React from 'react'
import RN from 'react-native'
import {render} from '@testing-library/react-native'
import {GestureHandlerRootView} from 'react-native-gesture-handler'
import {RootSiblingParent} from 'react-native-root-siblings'
import {SafeAreaProvider} from 'react-native-safe-area-context'
import {DEFAULT_SERVICE, RootStoreModel, RootStoreProvider} from '../src/state'
import {SessionServiceClient} from '../src/third-party/api/src'
import {sessionClient as AtpApi} from '../src/third-party/api'
import {RootStoreProvider} from '../src/state'
import {mockedRootStore} from '../__mocks__/state-mock'
const WrappedComponent = ({children}: any) => {
const api = AtpApi.service(DEFAULT_SERVICE) as SessionServiceClient
const rootStore = new RootStoreModel(api)
return (
const customRender = (ui: any, storeMock?: any) =>
render(
// eslint-disable-next-line react-native/no-inline-styles
<GestureHandlerRootView style={{flex: 1}}>
<RootSiblingParent>
<RootStoreProvider value={rootStore}>
<SafeAreaProvider>{children}</SafeAreaProvider>
<RootStoreProvider
value={
storeMock != null
? {...mockedRootStore, ...storeMock}
: mockedRootStore
}>
<SafeAreaProvider>{ui}</SafeAreaProvider>
</RootStoreProvider>
</RootSiblingParent>
</GestureHandlerRootView>
</GestureHandlerRootView>,
)
}
const customRender = (ui: any, options?: any) =>
render(ui, {wrapper: WrappedComponent, ...options})
// re-export everything
export * from '@testing-library/react-native'

6
package.json
View File

@ -9,8 +9,7 @@
"start": "react-native start",
"clean-cache": "rm -rf node_modules/.cache/babel-loader/*",
"test": "jest --coverage",
"lint": "eslint . --ext .js,.jsx,.ts,.tsx",
"postinstall": "patch-package"
"lint": "eslint . --ext .js,.jsx,.ts,.tsx"
},
"dependencies": {
"@atproto/api": "^0.0.6",
@ -34,7 +33,6 @@
"lru_map": "^0.4.1",
"mobx": "^6.6.1",
"mobx-react-lite": "^3.4.0",
"patch-package": "^6.5.0",
"react": "17.0.2",
"react-circular-progressbar": "^2.1.0",
"react-dom": "17.0.2",
@ -112,6 +110,8 @@
"<rootDir>/node_modules/",
"<rootDir>/src/platform",
"<rootDir>/src/third-party",
"<rootDir>/src/view/com/util",
"<rootDir>/src/state/lib",
"<rootDir>/__tests__/test-utils.js"
]
},

125
patches/react-native-pager-view+5.4.1.patch
View File

File diff suppressed because one or more lines are too long

1
src/view/com/composer/Autocomplete.tsx
View File

@ -46,6 +46,7 @@ export function Autocomplete({
<Animated.View style={[styles.outer, pal.view, pal.border, topAnimStyle]}>
{items.map((item, i) => (
<TouchableOpacity
testID="autocompleteButton"
key={i}
style={[pal.border, styles.item]}
onPress={() => onSelect(item.handle)}>

16
src/view/com/composer/ComposePost.tsx
View File

@ -56,11 +56,12 @@ export const ComposePost = observer(function ComposePost({
const [isSelectingPhotos, setIsSelectingPhotos] = useState(false)
const [selectedPhotos, setSelectedPhotos] = useState<string[]>([])
const autocompleteView = useMemo<UserAutocompleteViewModel>(
// Using default import (React.use...) instead of named import (use...) to be able to mock store's data in jest environment
const autocompleteView = React.useMemo<UserAutocompleteViewModel>(
() => new UserAutocompleteViewModel(store),
[store],
)
const localPhotos = useMemo<UserLocalPhotosModel>(
const localPhotos = React.useMemo<UserLocalPhotosModel>(
() => new UserLocalPhotosModel(store),
[store],
)
@ -179,11 +180,14 @@ export const ComposePost = observer(function ComposePost({
return (
<KeyboardAvoidingView
testID="composePostView"
behavior={Platform.OS === 'ios' ? 'padding' : 'height'}
style={[pal.view, styles.outer]}>
<SafeAreaView style={s.flex1}>
<View style={styles.topbar}>
<TouchableOpacity onPress={onPressCancel}>
<TouchableOpacity
testID="composerCancelButton"
onPress={onPressCancel}>
<Text style={[pal.link, s.f18]}>Cancel</Text>
</TouchableOpacity>
<View style={s.flex1} />
@ -192,7 +196,9 @@ export const ComposePost = observer(function ComposePost({
<ActivityIndicator />
</View>
) : canPost ? (
<TouchableOpacity onPress={onPressPublish}>
<TouchableOpacity
testID="composerPublishButton"
onPress={onPressPublish}>
<LinearGradient
colors={[gradients.primary.start, gradients.primary.end]}
start={{x: 0, y: 0}}
@ -257,6 +263,7 @@ export const ComposePost = observer(function ComposePost({
size={50}
/>
<TextInput
testID="composerTextInput"
ref={textInput}
multiline
scrollEnabled
@ -283,6 +290,7 @@ export const ComposePost = observer(function ComposePost({
)}
<View style={[pal.border, styles.bottomBar]}>
<TouchableOpacity
testID="composerSelectPhotosButton"
onPress={onPressSelectPhotos}
style={[s.pl5]}
hitSlop={HITSLOP}>

4
src/view/com/composer/PhotoCarouselPicker.tsx
View File

@ -85,21 +85,25 @@ export const PhotoCarouselPicker = ({
return (
<ScrollView
testID="photoCarouselPickerView"
horizontal
style={[pal.view, styles.photosContainer]}
showsHorizontalScrollIndicator={false}>
<TouchableOpacity
testID="openCameraButton"
style={[styles.galleryButton, pal.border, styles.photo]}
onPress={handleOpenCamera}>
<FontAwesomeIcon icon="camera" size={24} style={pal.link} />
</TouchableOpacity>
<TouchableOpacity
testID="openGalleryButton"
style={[styles.galleryButton, pal.border, styles.photo]}
onPress={handleOpenGallery}>
<FontAwesomeIcon icon="image" style={pal.link} size={24} />
</TouchableOpacity>
{localPhotos.photos.map((item: any, index: number) => (
<TouchableOpacity
testID="openSelectPhotoButton"
key={`local-image-${index}`}
style={[pal.border, styles.photoButton]}
onPress={() => handleSelectPhoto(item.node.image.uri)}>

1
src/view/com/composer/Prompt.tsx
View File

@ -17,6 +17,7 @@ export function ComposePrompt({
const pal = usePalette('default')
return (
<TouchableOpacity
testID="composePromptButton"
style={[
pal.view,
pal.border,

9
src/view/com/composer/SelectedPhoto.tsx
View File

@ -25,13 +25,14 @@ export const SelectedPhoto = ({
)
return selectedPhotos.length !== 0 ? (
<View style={styles.imageContainer}>
<View testID="selectedPhotosView" style={styles.imageContainer}>
{selectedPhotos.length !== 0 &&
selectedPhotos.map((item, index) => (
<View
key={`selected-image-${index}`}
style={[styles.image, imageStyle]}>
<TouchableOpacity
testID="removePhotoButton"
onPress={() => handleRemovePhoto(item)}
style={styles.removePhotoButton}>
<FontAwesomeIcon
@ -41,7 +42,11 @@ export const SelectedPhoto = ({
/>
</TouchableOpacity>
<Image style={[styles.image, imageStyle]} source={{uri: item}} />
<Image
testID="selectedPhotoImage"
style={[styles.image, imageStyle]}
source={{uri: item}}
/>
</View>
))}
</View>

5
src/view/com/discover/SuggestedFollows.tsx
View File

@ -1,4 +1,4 @@
import React, {useMemo, useEffect, useState} from 'react'
import React, {useEffect, useState} from 'react'
import {
ActivityIndicator,
FlatList,
@ -36,7 +36,8 @@ export const SuggestedFollows = observer(
const store = useStores()
const [follows, setFollows] = useState<Record<string, string>>({})
const view = useMemo<SuggestedActorsViewModel>(
// Using default import (React.use...) instead of named import (use...) to be able to mock store's data in jest environment
const view = React.useMemo<SuggestedActorsViewModel>(
() => new SuggestedActorsViewModel(store),
[],
)

15
src/view/com/login/CreateAccount.tsx
View File

@ -171,7 +171,7 @@ export const CreateAccount = ({onPressBack}: {onPressBack: () => void}) => {
const isReady = !!email && !!password && !!handle && is13
return (
<ScrollView style={{flex: 1}}>
<ScrollView testID="createAccount" style={{flex: 1}}>
<KeyboardAvoidingView behavior="padding" style={{flex: 1}}>
<View style={styles.logoHero}>
<Logo />
@ -193,6 +193,7 @@ export const CreateAccount = ({onPressBack}: {onPressBack: () => void}) => {
<View style={styles.groupContent}>
<FontAwesomeIcon icon="globe" style={styles.groupContentIcon} />
<TouchableOpacity
testID="registerSelectServiceButton"
style={styles.textBtn}
onPress={onPressSelectService}>
<Text style={styles.textBtnLabel}>
@ -235,6 +236,7 @@ export const CreateAccount = ({onPressBack}: {onPressBack: () => void}) => {
style={styles.groupContentIcon}
/>
<TextInput
testID="registerEmailInput"
style={[styles.textInput]}
placeholder="Email address"
placeholderTextColor={colors.blue0}
@ -248,6 +250,7 @@ export const CreateAccount = ({onPressBack}: {onPressBack: () => void}) => {
<View style={styles.groupContent}>
<FontAwesomeIcon icon="lock" style={styles.groupContentIcon} />
<TextInput
testID="registerPasswordInput"
style={[styles.textInput]}
placeholder="Choose your password"
placeholderTextColor={colors.blue0}
@ -273,6 +276,7 @@ export const CreateAccount = ({onPressBack}: {onPressBack: () => void}) => {
<View style={styles.groupContent}>
<FontAwesomeIcon icon="at" style={styles.groupContentIcon} />
<TextInput
testID="registerHandleInput"
style={[styles.textInput]}
placeholder="eg alice"
placeholderTextColor={colors.blue0}
@ -317,6 +321,7 @@ export const CreateAccount = ({onPressBack}: {onPressBack: () => void}) => {
</View>
<View style={styles.groupContent}>
<TouchableOpacity
testID="registerIs13Input"
style={styles.textBtn}
onPress={() => setIs13(!is13)}>
<View style={is13 ? styles.checkboxFilled : styles.checkbox}>
@ -339,7 +344,9 @@ export const CreateAccount = ({onPressBack}: {onPressBack: () => void}) => {
</TouchableOpacity>
<View style={s.flex1} />
{isReady ? (
<TouchableOpacity onPress={onPressNext}>
<TouchableOpacity
testID="createAccountButton"
onPress={onPressNext}>
{isProcessing ? (
<ActivityIndicator color="#fff" />
) : (
@ -347,7 +354,9 @@ export const CreateAccount = ({onPressBack}: {onPressBack: () => void}) => {
)}
</TouchableOpacity>
) : !serviceDescription && error ? (
<TouchableOpacity onPress={onPressRetryConnect}>
<TouchableOpacity
testID="registerRetryButton"
onPress={onPressRetryConnect}>
<Text style={[s.white, s.f18, s.bold, s.pr5]}>Retry</Text>
</TouchableOpacity>
) : !serviceDescription ? (

26
src/view/com/login/Signin.tsx
View File

@ -69,7 +69,7 @@ export const Signin = ({onPressBack}: {onPressBack: () => void}) => {
const onPressRetryConnect = () => setRetryDescribeTrigger({})
return (
<KeyboardAvoidingView behavior="padding" style={{flex: 1}}>
<KeyboardAvoidingView testID="signIn" behavior="padding" style={{flex: 1}}>
<View style={styles.logoHero}>
<Logo />
</View>
@ -194,8 +194,9 @@ const LoginForm = ({
const isReady = !!serviceDescription && !!handle && !!password
return (
<>
<View style={styles.group}>
<View testID="loginFormView" style={styles.group}>
<TouchableOpacity
testID="loginSelectServiceButton"
style={[styles.groupTitle, {paddingRight: 0, paddingVertical: 6}]}
onPress={onPressSelectService}>
<Text style={[s.flex1, s.white, s.f18, s.bold]} numberOfLines={1}>
@ -213,6 +214,7 @@ const LoginForm = ({
<View style={styles.groupContent}>
<FontAwesomeIcon icon="at" style={styles.groupContentIcon} />
<TextInput
testID="loginUsernameInput"
style={styles.textInput}
placeholder="Username"
placeholderTextColor={colors.blue0}
@ -227,6 +229,7 @@ const LoginForm = ({
<View style={styles.groupContent}>
<FontAwesomeIcon icon="lock" style={styles.groupContentIcon} />
<TextInput
testID="loginPasswordInput"
style={styles.textInput}
placeholder="Password"
placeholderTextColor={colors.blue0}
@ -238,6 +241,7 @@ const LoginForm = ({
editable={!isProcessing}
/>
<TouchableOpacity
testID="forgotPasswordButton"
style={styles.textInputInnerBtn}
onPress={onPressForgotPassword}>
<Text style={styles.textInputInnerBtnLabel}>Forgot</Text>
@ -260,7 +264,9 @@ const LoginForm = ({
</TouchableOpacity>
<View style={s.flex1} />
{!serviceDescription && error ? (
<TouchableOpacity onPress={onPressRetryConnect}>
<TouchableOpacity
testID="loginRetryButton"
onPress={onPressRetryConnect}>
<Text style={[s.white, s.f18, s.bold, s.pr5]}>Retry</Text>
</TouchableOpacity>
) : !serviceDescription ? (
@ -271,7 +277,7 @@ const LoginForm = ({
) : isProcessing ? (
<ActivityIndicator color="#fff" />
) : isReady ? (
<TouchableOpacity onPress={onPressNext}>
<TouchableOpacity testID="loginNextButton" onPress={onPressNext}>
<Text style={[s.white, s.f18, s.bold, s.pr5]}>Next</Text>
</TouchableOpacity>
) : undefined}
@ -339,8 +345,9 @@ const ForgotPasswordForm = ({
Enter the email you used to create your account. We'll send you a "reset
code" so you can set a new password.
</Text>
<View style={styles.group}>
<View testID="forgotPasswordView" style={styles.group}>
<TouchableOpacity
testID="forgotPasswordSelectServiceButton"
style={[styles.groupContent, {borderTopWidth: 0}]}
onPress={onPressSelectService}>
<FontAwesomeIcon icon="globe" style={styles.groupContentIcon} />
@ -359,6 +366,7 @@ const ForgotPasswordForm = ({
<View style={styles.groupContent}>
<FontAwesomeIcon icon="envelope" style={styles.groupContentIcon} />
<TextInput
testID="forgotPasswordEmail"
style={styles.textInput}
placeholder="Email address"
placeholderTextColor={colors.blue0}
@ -391,7 +399,7 @@ const ForgotPasswordForm = ({
) : !email ? (
<Text style={[s.blue1, s.f18, s.bold, s.pr5]}>Next</Text>
) : (
<TouchableOpacity onPress={onPressNext}>
<TouchableOpacity testID="newPasswordButton" onPress={onPressNext}>
<Text style={[s.white, s.f18, s.bold, s.pr5]}>Next</Text>
</TouchableOpacity>
)}
@ -451,10 +459,11 @@ const SetNewPasswordForm = ({
You will receive an email with a "reset code." Enter that code here,
then enter your new password.
</Text>
<View style={styles.group}>
<View testID="newPasswordView" style={styles.group}>
<View style={[styles.groupContent, {borderTopWidth: 0}]}>
<FontAwesomeIcon icon="ticket" style={styles.groupContentIcon} />
<TextInput
testID="resetCodeInput"
style={[styles.textInput]}
placeholder="Reset code"
placeholderTextColor={colors.blue0}
@ -469,6 +478,7 @@ const SetNewPasswordForm = ({
<View style={styles.groupContent}>
<FontAwesomeIcon icon="lock" style={styles.groupContentIcon} />
<TextInput
testID="newPasswordInput"
style={styles.textInput}
placeholder="New password"
placeholderTextColor={colors.blue0}
@ -501,7 +511,7 @@ const SetNewPasswordForm = ({
) : !resetCode || !password ? (
<Text style={[s.blue1, s.f18, s.bold, s.pr5]}>Next</Text>
) : (
<TouchableOpacity onPress={onPressNext}>
<TouchableOpacity testID="setNewPasswordButton" onPress={onPressNext}>
<Text style={[s.white, s.f18, s.bold, s.pr5]}>Next</Text>
</TouchableOpacity>
)}

9
src/view/com/notifications/InviteAccepter.tsx
View File

@ -1,4 +1,4 @@
import React, {useState} from 'react'
import React from 'react'
import {StyleSheet, TouchableOpacity, View} from 'react-native'
import LinearGradient from 'react-native-linear-gradient'
import {FontAwesomeIcon} from '@fortawesome/react-native-fontawesome'
@ -13,7 +13,8 @@ import {s, colors, gradients} from '../../lib/styles'
export function InviteAccepter({item}: {item: NotificationsViewItemModel}) {
const store = useStores()
const [confirmationUri, setConfirmationUri] = useState<string>('')
// Using default import (React.use...) instead of named import (use...) to be able to mock store's data in jest environment
const [confirmationUri, setConfirmationUri] = React.useState<string>('')
const isMember =
confirmationUri !== '' || store.me.memberships?.isMemberOf(item.author.did)
const onPressAccept = async () => {
@ -54,7 +55,7 @@ export function InviteAccepter({item}: {item: NotificationsViewItemModel}) {
return (
<View style={styles.container}>
{!isMember ? (
<TouchableOpacity onPress={onPressAccept}>
<TouchableOpacity testID="acceptInviteButton" onPress={onPressAccept}>
<LinearGradient
colors={[gradients.primary.start, gradients.primary.end]}
start={{x: 0, y: 0}}
@ -64,7 +65,7 @@ export function InviteAccepter({item}: {item: NotificationsViewItemModel}) {
</LinearGradient>
</TouchableOpacity>
) : (
<View style={styles.inviteAccepted}>
<View testID="inviteAccepted" style={styles.inviteAccepted}>
<FontAwesomeIcon icon="check" size={14} style={s.mr5} />
<Text style={[s.gray5, s.f15]}>Invite accepted</Text>
</View>

5
src/view/com/post-thread/PostRepostedBy.tsx
View File

@ -1,4 +1,4 @@
import React, {useState, useEffect} from 'react'
import React, {useEffect} from 'react'
import {observer} from 'mobx-react-lite'
import {ActivityIndicator, FlatList, StyleSheet, View} from 'react-native'
import {
@ -18,7 +18,8 @@ export const PostRepostedBy = observer(function PostRepostedBy({
uri: string
}) {
const store = useStores()
const [view, setView] = useState<RepostedByViewModel | undefined>()
// Using default import (React.use...) instead of named import (use...) to be able to mock store's data in jest environment
const [view, setView] = React.useState<RepostedByViewModel | undefined>()
useEffect(() => {
if (view?.params.uri === uri) {

4
src/view/com/post-thread/PostVotedBy.tsx
View File

@ -1,4 +1,4 @@
import React, {useState, useEffect} from 'react'
import React, {useEffect} from 'react'
import {observer} from 'mobx-react-lite'
import {ActivityIndicator, FlatList, StyleSheet, View} from 'react-native'
import {
@ -20,7 +20,7 @@ export const PostVotedBy = observer(function PostVotedBy({
direction: 'up' | 'down'
}) {
const store = useStores()
const [view, setView] = useState<VotesViewModel | undefined>()
const [view, setView] = React.useState<VotesViewModel | undefined>()
useEffect(() => {
if (view?.params.uri === uri) {

4
src/view/com/posts/Feed.tsx
View File

@ -25,6 +25,7 @@ export const Feed = observer(function Feed({
onPressCompose,
onPressTryAgain,
onScroll,
testID,
}: {
feed: FeedModel
style?: StyleProp<ViewStyle>
@ -32,6 +33,7 @@ export const Feed = observer(function Feed({
onPressCompose: () => void
onPressTryAgain?: () => void
onScroll?: OnScrollCb
testID?: string
}) {
// TODO optimize renderItem or FeedItem, we're getting this notice from RN: -prf
// VirtualizedList: You have a large list that is slow to update - make sure your
@ -83,7 +85,7 @@ export const Feed = observer(function Feed({
<View />
)
return (
<View style={style}>
<View testID={testID} style={style}>
{!data && <ComposePrompt onPressCompose={onPressCompose} />}
{feed.isLoading && !data && <PostFeedLoadingPlaceholder />}
{feed.hasError && (

4
src/view/com/profile/ProfileFollowers.tsx
View File

@ -1,4 +1,4 @@
import React, {useState, useEffect} from 'react'
import React, {useEffect} from 'react'
import {observer} from 'mobx-react-lite'
import {ActivityIndicator, FlatList, StyleSheet, View} from 'react-native'
import {
@ -19,7 +19,7 @@ export const ProfileFollowers = observer(function ProfileFollowers({
name: string
}) {
const store = useStores()
const [view, setView] = useState<UserFollowersViewModel | undefined>()
const [view, setView] = React.useState<UserFollowersViewModel | undefined>()
useEffect(() => {
if (view?.params.user === name) {

6
src/view/com/profile/ProfileFollows.tsx
View File

@ -1,4 +1,4 @@
import React, {useState, useEffect} from 'react'
import React, {useEffect} from 'react'
import {observer} from 'mobx-react-lite'
import {ActivityIndicator, FlatList, StyleSheet, View} from 'react-native'
import {
@ -10,7 +10,7 @@ import {Link} from '../util/Link'
import {Text} from '../util/text/Text'
import {ErrorMessage} from '../util/error/ErrorMessage'
import {UserAvatar} from '../util/UserAvatar'
import {s, colors} from '../../lib/styles'
import {s} from '../../lib/styles'
import {usePalette} from '../../lib/hooks/usePalette'
export const ProfileFollows = observer(function ProfileFollows({
@ -19,7 +19,7 @@ export const ProfileFollows = observer(function ProfileFollows({
name: string
}) {
const store = useStores()
const [view, setView] = useState<UserFollowsViewModel | undefined>()
const [view, setView] = React.useState<UserFollowsViewModel | undefined>()
useEffect(() => {
if (view?.params.user === name) {

15
src/view/com/profile/ProfileHeader.tsx
View File

@ -147,7 +147,7 @@ export const ProfileHeader = observer(function ProfileHeader({
// =
if (view.hasError) {
return (
<View>
<View testID="profileHeaderHasError">
<Text>{view.error}</Text>
</View>
)
@ -192,6 +192,7 @@ export const ProfileHeader = observer(function ProfileHeader({
<View style={[styles.buttonsLine]}>
{isMe ? (
<TouchableOpacity
testID="profileHeaderEditProfileButton"
onPress={onPressEditProfile}
style={[styles.btn, styles.mainBtn, pal.btn]}>
<Text type="button" style={pal.text}>
@ -214,7 +215,9 @@ export const ProfileHeader = observer(function ProfileHeader({
</Text>
</TouchableOpacity>
) : (
<TouchableOpacity onPress={onPressToggleFollow}>
<TouchableOpacity
testID="profileHeaderToggleFollowButton"
onPress={onPressToggleFollow}>
<LinearGradient
colors={[gradient[1], gradient[0]]}
start={{x: 0, y: 0}}
@ -257,6 +260,7 @@ export const ProfileHeader = observer(function ProfileHeader({
</View>
<View style={styles.metricsLine}>
<TouchableOpacity
testID="profileHeaderFollowersButton"
style={[s.flexRow, s.mr10]}
onPress={onPressFollowers}>
<Text type="body2" style={[s.bold, s.mr2, pal.text]}>
@ -268,6 +272,7 @@ export const ProfileHeader = observer(function ProfileHeader({
</TouchableOpacity>
{view.isUser ? (
<TouchableOpacity
testID="profileHeaderFollowsButton"
style={[s.flexRow, s.mr10]}
onPress={onPressFollows}>
<Text type="body2" style={[s.bold, s.mr2, pal.text]}>
@ -280,6 +285,7 @@ export const ProfileHeader = observer(function ProfileHeader({
) : undefined}
{view.isScene ? (
<TouchableOpacity
testID="profileHeaderMembersButton"
style={[s.flexRow, s.mr10]}
onPress={onPressMembers}>
<Text type="body2" style={[s.bold, s.mr2, pal.text]}>
@ -350,7 +356,9 @@ export const ProfileHeader = observer(function ProfileHeader({
</View>
{view.isScene && view.creator === store.me.did ? (
<View style={[styles.sceneAdminContainer, pal.border]}>
<TouchableOpacity onPress={onPressInviteMembers}>
<TouchableOpacity
testID="profileHeaderInviteMembersButton"
onPress={onPressInviteMembers}>
<LinearGradient
colors={[gradient[1], gradient[0]]}
start={{x: 0, y: 0}}
@ -369,6 +377,7 @@ export const ProfileHeader = observer(function ProfileHeader({
</View>
) : undefined}
<TouchableOpacity
testID="profileHeaderAviButton"
style={[pal.view, {borderColor: pal.colors.background}, styles.avi]}
onPress={onPressAvi}>
<UserAvatar

9
src/view/com/profile/ProfileMembers.tsx
View File

@ -1,4 +1,4 @@
import React, {useState, useEffect} from 'react'
import React, {useEffect} from 'react'
import {observer} from 'mobx-react-lite'
import {ActivityIndicator, FlatList, View} from 'react-native'
import {MembersViewModel, MemberItem} from '../../../state/models/members-view'
@ -12,7 +12,8 @@ export const ProfileMembers = observer(function ProfileMembers({
name: string
}) {
const store = useStores()
const [view, setView] = useState<MembersViewModel | undefined>()
// Using default import (React.use...) instead of named import (use...) to be able to mock store's data in jest environment
const [view, setView] = React.useState<MembersViewModel | undefined>()
useEffect(() => {
if (view?.params.actor === name) {
@ -37,7 +38,7 @@ export const ProfileMembers = observer(function ProfileMembers({
view.params.actor !== name
) {
return (
<View>
<View testID="profileMembersActivityIndicatorView">
<ActivityIndicator />
</View>
)
@ -68,7 +69,7 @@ export const ProfileMembers = observer(function ProfileMembers({
/>
)
return (
<View>
<View testID="profileMembersFlatList">
<FlatList
data={view.members}
keyExtractor={item => item._reactKey}

3
src/view/com/util/PostCtrls.tsx
View File

@ -115,6 +115,7 @@ export function PostCtrls(opts: PostCtrlsOpts) {
<View style={[styles.ctrls, opts.style]}>
<View style={s.flex1}>
<TouchableOpacity
testID="postCtrlsReplyButton"
style={styles.ctrl}
hitSlop={HITSLOP}
onPress={opts.onPressReply}>
@ -130,6 +131,7 @@ export function PostCtrls(opts: PostCtrlsOpts) {
</View>
<View style={s.flex1}>
<TouchableOpacity
testID="postCtrlsToggleRepostButton"
hitSlop={HITSLOP}
onPress={onPressToggleRepostWrapper}
style={styles.ctrl}>
@ -156,6 +158,7 @@ export function PostCtrls(opts: PostCtrlsOpts) {
</View>
<View style={s.flex1}>
<TouchableOpacity
testID="postCtrlsToggleUpvoteButton"
style={styles.ctrl}
hitSlop={HITSLOP}
onPress={onPressToggleUpvoteWrapper}>

8
src/view/com/util/error/ErrorMessage.tsx
View File

@ -8,7 +8,6 @@ import {
} from 'react-native'
import {FontAwesomeIcon} from '@fortawesome/react-native-fontawesome'
import {Text} from '../text/Text'
import {colors} from '../../../lib/styles'
import {useTheme} from '../../../lib/ThemeContext'
import {usePalette} from '../../../lib/hooks/usePalette'
@ -26,7 +25,7 @@ export function ErrorMessage({
const theme = useTheme()
const pal = usePalette('error')
return (
<View style={[styles.outer, pal.view, style]}>
<View testID="errorMessageView" style={[styles.outer, pal.view, style]}>
<View
style={[styles.errorIcon, {backgroundColor: theme.palette.error.icon}]}>
<FontAwesomeIcon icon="exclamation" style={pal.text} size={16} />
@ -38,7 +37,10 @@ export function ErrorMessage({
{message}
</Text>
{onPressTryAgain && (
<TouchableOpacity style={styles.btn} onPress={onPressTryAgain}>
<TouchableOpacity
testID="errorMessageTryAgainButton"
style={styles.btn}
onPress={onPressTryAgain}>
<FontAwesomeIcon
icon="arrows-rotate"
style={{color: theme.palette.error.icon}}

6
src/view/com/util/error/ErrorScreen.tsx
View File

@ -11,16 +11,18 @@ export function ErrorScreen({
message,
details,
onPressTryAgain,
testID,
}: {
title: string
message: string
details?: string
onPressTryAgain?: () => void
testID?: string
}) {
const theme = useTheme()
const pal = usePalette('error')
return (
<View style={[styles.outer, pal.view]}>
<View testID={testID} style={[styles.outer, pal.view]}>
<View style={styles.errorIconContainer}>
<View
style={[
@ -40,6 +42,7 @@ export function ErrorScreen({
<Text style={[styles.message, pal.textLight]}>{message}</Text>
{details && (
<Text
testID={`${testID}-details`}
type="body2"
style={[
styles.details,
@ -52,6 +55,7 @@ export function ErrorScreen({
{onPressTryAgain && (
<View style={styles.btnContainer}>
<TouchableOpacity
testID="errorScreenTryAgainButton"
style={[styles.btn, {backgroundColor: theme.palette.error.icon}]}
onPress={onPressTryAgain}>
<FontAwesomeIcon icon="arrows-rotate" style={pal.text} size={16} />

3
src/view/com/util/forms/DropdownButton.tsx
View File

@ -75,7 +75,8 @@ export function DropdownButton({
style={style}
onPress={onPress}
hitSlop={HITSLOP}
ref={ref}>
// Fix an issue where specific references cause runtime error in jest environment
ref={process.env.JEST_WORKER_ID != null ? null : ref}>
{children}
</TouchableOpacity>
)

5
src/view/screens/Contacts.tsx
View File

@ -25,7 +25,9 @@ export const Contacts = ({navIdx, visible, params}: ScreenParams) => {
return (
<View>
<View style={styles.section}>
<Text style={styles.title}>Contacts</Text>
<Text testID="contactsTitle" style={styles.title}>
Contacts
</Text>
</View>
<View style={styles.section}>
<View style={styles.searchContainer}>
@ -35,6 +37,7 @@ export const Contacts = ({navIdx, visible, params}: ScreenParams) => {
style={styles.searchIcon}
/>
<TextInput
testID="contactsTextInput"
ref={inputRef}
value={searchText}
style={styles.searchInput}

53
src/view/screens/Home.tsx
View File

@ -1,4 +1,4 @@
import React, {useState, useEffect} from 'react'
import React, {useEffect} from 'react'
import {StyleSheet, TouchableOpacity, View} from 'react-native'
import {observer} from 'mobx-react-lite'
import useAppState from 'react-native-appstate-hook'
@ -24,48 +24,48 @@ export const Home = observer(function Home({
const store = useStores()
const onMainScroll = useOnMainScroll(store)
const safeAreaInsets = useSafeAreaInsets()
const [hasSetup, setHasSetup] = useState<boolean>(false)
const [wasVisible, setWasVisible] = React.useState<boolean>(false)
const {appState} = useAppState({
onForeground: () => doPoll(true),
})
const doPoll = (knownActive = false) => {
if ((!knownActive && appState !== 'active') || !visible) {
return
}
if (store.me.mainFeed.isLoading) {
return
}
store.log.debug('Polling home feed')
store.me.mainFeed.checkForLatest().catch(e => {
store.log.error('Failed to poll feed', e)
})
}
const doPoll = React.useCallback(
(knownActive = false) => {
if ((!knownActive && appState !== 'active') || !visible) {
return
}
if (store.me.mainFeed.isLoading) {
return
}
store.log.debug('Polling home feed')
store.me.mainFeed.checkForLatest().catch(e => {
store.log.error('Failed to poll feed', e)
})
},
[appState, visible, store],
)
useEffect(() => {
let aborted = false
const pollInterval = setInterval(() => doPoll(), 15e3)
if (!visible) {
setWasVisible(false)
return
} else if (wasVisible) {
return
}
setWasVisible(true)
if (hasSetup) {
store.log.debug('Updating home feed')
store.nav.setTitle(navIdx, 'Home')
store.log.debug('Updating home feed')
if (store.me.mainFeed.hasContent) {
store.me.mainFeed.update()
doPoll()
} else {
store.nav.setTitle(navIdx, 'Home')
store.log.debug('Fetching home feed')
store.me.mainFeed.setup().then(() => {
if (aborted) return
setHasSetup(true)
})
store.me.mainFeed.setup()
}
return () => {
clearInterval(pollInterval)
aborted = true
}
}, [visible, store])
}, [visible, store, navIdx, doPoll, wasVisible])
const onPressCompose = () => {
store.shell.openComposer({})
@ -82,6 +82,7 @@ export const Home = observer(function Home({
<View style={s.flex1}>
<ViewHeader title="Bluesky" subtitle="Private Beta" canGoBack={false} />
<Feed
testID="homeFeed"
key="default"
feed={store.me.mainFeed}
scrollElRef={scrollElRef}

12
src/view/screens/Login.tsx
View File

@ -35,8 +35,11 @@ const SigninOrCreateAccount = ({
<Text style={styles.title}>Bluesky</Text>
<Text style={styles.subtitle}>[ private beta ]</Text>
</View>
<View style={s.flex1}>
<TouchableOpacity style={styles.btn} onPress={onPressCreateAccount}>
<View testID="signinOrCreateAccount" style={s.flex1}>
<TouchableOpacity
testID="createAccountButton"
style={styles.btn}
onPress={onPressCreateAccount}>
<Text style={styles.btnLabel}>Create a new account</Text>
</TouchableOpacity>
<View style={styles.or}>
@ -60,7 +63,10 @@ const SigninOrCreateAccount = ({
</Svg>
<Text style={styles.orLabel}>or</Text>
</View>
<TouchableOpacity style={styles.btn} onPress={onPressSignin}>
<TouchableOpacity
testID="signInButton"
style={styles.btn}
onPress={onPressSignin}>
<Text style={styles.btnLabel}>Sign in</Text>
</TouchableOpacity>
</View>

8
src/view/screens/NotFound.tsx
View File

@ -7,7 +7,7 @@ import {useStores} from '../../state'
export const NotFound = () => {
const stores = useStores()
return (
<View>
<View testID="notFoundView">
<ViewHeader title="Page not found" />
<View
style={{
@ -16,7 +16,11 @@ export const NotFound = () => {
paddingTop: 100,
}}>
<Text style={{fontSize: 40, fontWeight: 'bold'}}>Page not found</Text>
<Button title="Home" onPress={() => stores.nav.navigate('/')} />
<Button
testID="navigateHomeButton"
title="Home"
onPress={() => stores.nav.navigate('/')}
/>
</View>
</View>
)

8
src/view/screens/Profile.tsx
View File

@ -1,4 +1,4 @@
import React, {useEffect, useState, useMemo} from 'react'
import React, {useEffect, useState} from 'react'
import {ActivityIndicator, StyleSheet, View} from 'react-native'
import {observer} from 'mobx-react-lite'
import {FontAwesomeIcon} from '@fortawesome/react-native-fontawesome'
@ -30,7 +30,7 @@ export const Profile = observer(({navIdx, visible, params}: ScreenParams) => {
const store = useStores()
const onMainScroll = useOnMainScroll(store)
const [hasSetup, setHasSetup] = useState<boolean>(false)
const uiState = useMemo(
const uiState = React.useMemo(
() => new ProfileUiModel(store, {user: params.name}),
[params.user],
)
@ -201,6 +201,7 @@ export const Profile = observer(({navIdx, visible, params}: ScreenParams) => {
? () => (
<>
<FontAwesomeIcon
testID="shouldAdminButton"
icon="user-xmark"
style={[s.mr5]}
size={14}
@ -242,10 +243,11 @@ export const Profile = observer(({navIdx, visible, params}: ScreenParams) => {
const title =
uiState.profile.displayName || uiState.profile.handle || params.name
return (
<View style={styles.container}>
<View testID="profileView" style={styles.container}>
<ViewHeader title={title} />
{uiState.profile.hasError ? (
<ErrorScreen
testID="profileErrorScreen"
title="Failed to load profile"
message={`There was an issue when attempting to load ${params.name}`}
details={uiState.profile.error}

3
src/view/screens/Search.tsx
View File

@ -57,6 +57,7 @@ export const Search = ({navIdx, visible, params}: ScreenParams) => {
<View style={[pal.view, pal.border, styles.inputContainer]}>
<MagnifyingGlassIcon style={[pal.text, styles.inputIcon]} />
<TextInput
testID="searchTextInput"
ref={textInput}
placeholder="Type your query here..."
placeholderTextColor={pal.colors.textLight}
@ -68,7 +69,7 @@ export const Search = ({navIdx, visible, params}: ScreenParams) => {
</View>
<View style={styles.outputContainer}>
{query ? (
<ScrollView onScroll={Keyboard.dismiss}>
<ScrollView testID="searchScrollView" onScroll={Keyboard.dismiss}>
{autocompleteView.searchRes.map((item, i) => (
<TouchableOpacity
key={i}

5
src/view/shell/mobile/Menu.tsx
View File

@ -75,6 +75,7 @@ export const Menu = observer(
onPress?: () => void
}) => (
<TouchableOpacity
testID="menuItemButton"
style={styles.menuItem}
onPress={onPress ? onPress : () => onNavigate(url || '/')}>
<View style={[styles.menuItemIconWrapper]}>
@ -98,8 +99,9 @@ export const Menu = observer(
)
return (
<ScrollView style={[styles.view, pal.view]}>
<ScrollView testID="menuView" style={[styles.view, pal.view]}>
<TouchableOpacity
testID="profileCardButton"
onPress={() => onNavigate(`/profile/${store.me.handle}`)}
style={styles.profileCard}>
<UserAvatar
@ -123,6 +125,7 @@ export const Menu = observer(
</View>
</TouchableOpacity>
<TouchableOpacity
testID="searchBtn"
style={[styles.searchBtn, pal.btn]}
onPress={() => onNavigate('/search')}>
<MagnifyingGlassIcon

18
src/view/shell/mobile/TabsSelector.tsx
View File

@ -116,11 +116,12 @@ export const TabsSelector = observer(
}
if (!active) {
return <View />
return <View testID="emptyView" />
}
return (
<Animated.View
testID="tabsSelectorView"
style={[
styles.wrapper,
{bottom: insets.bottom + 55},
@ -129,7 +130,9 @@ export const TabsSelector = observer(
<View onLayout={onLayout}>
<View style={[s.p10, styles.section]}>
<View style={styles.btns}>
<TouchableWithoutFeedback onPress={onPressShareTab}>
<TouchableWithoutFeedback
testID="shareButton"
onPress={onPressShareTab}>
<View style={[styles.btn]}>
<View style={styles.btnIcon}>
<FontAwesomeIcon size={16} icon="share" />
@ -137,7 +140,9 @@ export const TabsSelector = observer(
<Text style={styles.btnText}>Share</Text>
</View>
</TouchableWithoutFeedback>
<TouchableWithoutFeedback onPress={onPressCloneTab}>
<TouchableWithoutFeedback
testID="cloneButton"
onPress={onPressCloneTab}>
<View style={[styles.btn]}>
<View style={styles.btnIcon}>
<FontAwesomeIcon size={16} icon={['far', 'clone']} />
@ -145,7 +150,9 @@ export const TabsSelector = observer(
<Text style={styles.btnText}>Clone tab</Text>
</View>
</TouchableWithoutFeedback>
<TouchableWithoutFeedback onPress={onPressNewTab}>
<TouchableWithoutFeedback
testID="newTabButton"
onPress={onPressNewTab}>
<View style={[styles.btn]}>
<View style={styles.btnIcon}>
<FontAwesomeIcon size={16} icon="plus" />
@ -164,6 +171,7 @@ export const TabsSelector = observer(
return (
<Swipeable
key={tab.id}
testID="tabsSwipable"
renderLeftActions={renderSwipeActions}
renderRightActions={renderSwipeActions}
leftThreshold={100}
@ -185,6 +193,7 @@ export const TabsSelector = observer(
isActive && styles.active,
]}>
<TouchableWithoutFeedback
testID="changeTabButton"
onPress={() => onPressChangeTab(tabIndex)}>
<View style={styles.tabInner}>
<View style={styles.tabIcon}>
@ -203,6 +212,7 @@ export const TabsSelector = observer(
</View>
</TouchableWithoutFeedback>
<TouchableWithoutFeedback
testID="closeTabButton"
onPress={() => onCloseTab(tabIndex)}>
<View style={styles.tabClose}>
<FontAwesomeIcon

6
src/view/shell/mobile/index.tsx
View File

@ -327,7 +327,7 @@ export const MobileShell: React.FC = observer(() => {
start={{x: 0, y: 0.8}}
end={{x: 0, y: 1}}
style={styles.outerContainer}>
<SafeAreaView style={styles.innerContainer}>
<SafeAreaView testID="noSessionView" style={styles.innerContainer}>
<ErrorBoundary>
<Login />
</ErrorBoundary>
@ -338,7 +338,7 @@ export const MobileShell: React.FC = observer(() => {
}
if (store.onboard.isOnboarding) {
return (
<View style={styles.outerContainer}>
<View testID="onboardOuterView" style={styles.outerContainer}>
<View style={styles.innerContainer}>
<ErrorBoundary>
<Onboard />
@ -355,7 +355,7 @@ export const MobileShell: React.FC = observer(() => {
backgroundColor: theme.colorScheme === 'dark' ? colors.gray7 : colors.gray1,
}
return (
<View style={[styles.outerContainer, pal.view]}>
<View testID="mobileShellView" style={[styles.outerContainer, pal.view]}>
<StatusBar
barStyle={
theme.colorScheme === 'dark' ? 'light-content' : 'dark-content'

67
yarn.lock
View File

@ -3027,11 +3027,6 @@
resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d"
integrity sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==
"@yarnpkg/lockfile@^1.1.0":
version "1.1.0"
resolved "https://registry.yarnpkg.com/@yarnpkg/lockfile/-/lockfile-1.1.0.tgz#e77a97fbd345b76d83245edcd17d393b1b41fb31"
integrity sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ==
"@zxing/text-encoding@^0.9.0":
version "0.9.0"
resolved "https://registry.yarnpkg.com/@zxing/text-encoding/-/text-encoding-0.9.0.tgz#fb50ffabc6c7c66a0c96b4c03e3d9be74864b70b"
@ -4389,7 +4384,7 @@ cross-fetch@^3.1.5:
dependencies:
node-fetch "2.6.7"
cross-spawn@^6.0.0, cross-spawn@^6.0.5:
cross-spawn@^6.0.0:
version "6.0.5"
resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
@ -5930,13 +5925,6 @@ find-up@^5.0.0:
locate-path "^6.0.0"
path-exists "^4.0.0"
find-yarn-workspace-root@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/find-yarn-workspace-root/-/find-yarn-workspace-root-2.0.0.tgz#f47fb8d239c900eb78179aa81b66673eac88f7bd"
integrity sha512-1IMnbjt4KzsQfnhnzNd8wUEgXZ44IzZaZmnLYx7D5FZlaHt2gW20Cri8Q+E/t5tIj4+epTBub+2Zxu/vNILzqQ==
dependencies:
micromatch "^4.0.2"
flat-cache@^3.0.4:
version "3.0.4"
resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11"
@ -6999,7 +6987,7 @@ is-wsl@^1.1.0:
resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-1.1.0.tgz#1f16e4aa22b04d1336b66188a66af3c600c3a66d"
integrity sha512-gfygJYZ2gLTDlmbWMI0CE2MwnFzSN/2SZfkMlItC4K/JBlsWVDB0bO6XhqcY13YXE7iMcAJnzTCJjPiTeJJ0Mw==
is-wsl@^2.1.1, is-wsl@^2.2.0:
is-wsl@^2.2.0:
version "2.2.0"
resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271"
integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
@ -8177,13 +8165,6 @@ kind-of@^6.0.0, kind-of@^6.0.2:
resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
klaw-sync@^6.0.0:
version "6.0.0"
resolved "https://registry.yarnpkg.com/klaw-sync/-/klaw-sync-6.0.0.tgz#1fd2cfd56ebb6250181114f0a581167099c2b28c"
integrity sha512-nIeuVSzdCCs6TDPTqI8w1Yre34sSq7AkZ4B3sfOBbI2CgVSB4Du4aLQijFU2+lhAFCwt9+42Hel6lQNIv6AntQ==
dependencies:
graceful-fs "^4.1.11"
klaw@^1.0.0:
version "1.3.1"
resolved "https://registry.yarnpkg.com/klaw/-/klaw-1.3.1.tgz#4088433b46b3b1ba259d78785d8e96f73ba02439"
@ -9217,14 +9198,6 @@ open@^6.2.0:
dependencies:
is-wsl "^1.1.0"
open@^7.4.2:
version "7.4.2"
resolved "https://registry.yarnpkg.com/open/-/open-7.4.2.tgz#b8147e26dcf3e426316c730089fd71edd29c2321"
integrity sha512-MVHddDVweXZF3awtlAS+6pgKLlm/JgxZ90+/NBurBoQctVOOB/zDdVjcyPzQ+0laDGbsWgrRkflI65sQeOgT9Q==
dependencies:
is-docker "^2.0.0"
is-wsl "^2.1.1"
open@^8.0.9, open@^8.4.0:
version "8.4.0"
resolved "https://registry.yarnpkg.com/open/-/open-8.4.0.tgz#345321ae18f8138f82565a910fdc6b39e8c244f8"
@ -9290,7 +9263,7 @@ ora@^5.4.1:
strip-ansi "^6.0.0"
wcwidth "^1.0.1"
os-tmpdir@^1.0.0, os-tmpdir@~1.0.2:
os-tmpdir@^1.0.0:
version "1.0.2"
resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
integrity sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==
@ -9409,26 +9382,6 @@ pascalcase@^0.1.1:
resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
integrity sha512-XHXfu/yOQRy9vYOtUDVMN60OEJjW013GoObG1o+xwQTpB9eYJX/BjXMsdW13ZDPruFhYYn0AG22w0xgQMwl3Nw==
patch-package@^6.5.0:
version "6.5.1"
resolved "https://registry.yarnpkg.com/patch-package/-/patch-package-6.5.1.tgz#3e5d00c16997e6160291fee06a521c42ac99b621"
integrity sha512-I/4Zsalfhc6bphmJTlrLoOcAF87jcxko4q0qsv4bGcurbr8IskEOtdnt9iCmsQVGL1B+iUhSQqweyTLJfCF9rA==
dependencies:
"@yarnpkg/lockfile" "^1.1.0"
chalk "^4.1.2"
cross-spawn "^6.0.5"
find-yarn-workspace-root "^2.0.0"
fs-extra "^9.0.0"
is-ci "^2.0.0"
klaw-sync "^6.0.0"
minimist "^1.2.6"
open "^7.4.2"
rimraf "^2.6.3"
semver "^5.6.0"
slash "^2.0.0"
tmp "^0.0.33"
yaml "^1.10.2"
path-exists@^3.0.0:
version "3.0.0"
resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
@ -10973,7 +10926,7 @@ reusify@^1.0.4:
resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
rimraf@^2.5.4, rimraf@^2.6.3:
rimraf@^2.5.4:
version "2.7.1"
resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.7.1.tgz#35797f13a7fdadc566142c29d4f07ccad483e3ec"
integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==
@ -11348,11 +11301,6 @@ sisteransi@^1.0.5:
resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed"
integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==
slash@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/slash/-/slash-2.0.0.tgz#de552851a1759df3a8f206535442f5ec4ddeab44"
integrity sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==
slash@^3.0.0:
version "3.0.0"
resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
@ -11991,13 +11939,6 @@ tlds@^1.234.0:
resolved "https://registry.yarnpkg.com/tlds/-/tlds-1.236.0.tgz#a118eebe33261c577e3a3025144faeabb7dd813c"
integrity sha512-oP2PZ3KeGlgpHgsEfrtva3/K9kzsJUNliQSbCfrJ7JMCWFoCdtG+9YMq/g2AnADQ1v5tVlbtvKJZ4KLpy/P6MA==
tmp@^0.0.33:
version "0.0.33"
resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==
dependencies:
os-tmpdir "~1.0.2"
tmpl@1.0.5:
version "1.0.5"
resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.5.tgz#8683e0b902bb9c20c4f726e3c0b69f36518c07cc"