initial commit

test/__init__.py

@@ -0,0 +1,5 @@
+import os
+import sys
+
+
+sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src'))

test/conftest.py

@@ -0,0 +1,128 @@
+import os
+import pytest
+import tempfile
+
+from typing import Any, List
+
+from service.api.web import setup_service
+from service.core.ariyala_parser import AriyalaParser
+from service.core.config import Configuration
+from service.core.database import Database
+from service.core.loot_selector import LootSelector
+from service.core.party import Party
+from service.core.sqlite import SQLiteDatabase
+from service.models.bis import BiS
+from service.models.job import Job
+from service.models.piece import Head, Piece, Weapon
+from service.models.player import Player
+
+
+@pytest.fixture
+def parser(config: Configuration) -> AriyalaParser:
+    return AriyalaParser(config)
+
+
+@pytest.fixture
+def bis() -> BiS:
+    return BiS()
+
+
+@pytest.fixture
+def bis2() -> BiS:
+    return BiS()
+
+
+@pytest.fixture
+def bis_link() -> str:
+    return 'https://ffxiv.ariyala.com/19V5R'
+
+
+@pytest.fixture
+def bis_set() -> List[Piece]:
+    items: List[Piece] = []
+    items.append(Piece.get({'piece': 'weapon', 'is_tome': False}))
+    items.append(Piece.get({'piece': 'head', 'is_tome': False}))
+    items.append(Piece.get({'piece': 'body', 'is_tome': False}))
+    items.append(Piece.get({'piece': 'hands', 'is_tome': True}))
+    items.append(Piece.get({'piece': 'waist', 'is_tome': True}))
+    items.append(Piece.get({'piece': 'legs', 'is_tome': True}))
+    items.append(Piece.get({'piece': 'feet', 'is_tome': False}))
+    items.append(Piece.get({'piece': 'ears', 'is_tome': False}))
+    items.append(Piece.get({'piece': 'neck', 'is_tome': True}))
+    items.append(Piece.get({'piece': 'wrist', 'is_tome': False}))
+    items.append(Piece.get({'piece': 'left_ring', 'is_tome': True}))
+    items.append(Piece.get({'piece': 'right_ring', 'is_tome': True}))
+
+    return items
+
+
+@pytest.fixture
+def config() -> Configuration:
+    config = Configuration()
+    config.load('/dev/null', {
+        'ariyala': {
+            'ariyala_url': 'https://ffxiv.ariyala.com',
+            'request_timeout': 1,
+            'xivapi_url': 'https://xivapi.com'
+        },
+        'settings': {
+            'include': '/dev/null'
+        }
+    })
+    return config
+
+
+@pytest.fixture
+def database() -> SQLiteDatabase:
+    db = SQLiteDatabase(
+        tempfile.mktemp('-ffxivbis.db'),
+        os.path.join(os.path.dirname(os.path.dirname(__file__)), 'migrations'))
+    db.migration()
+    return db
+
+
+@pytest.fixture
+def head_with_upgrade() -> Piece:
+    return Head(is_tome=True)
+
+
+@pytest.fixture
+def party(database: Database) -> Party:
+    return Party(database)
+
+
+@pytest.fixture
+def player(bis: BiS) -> Player:
+    return Player(Job.WHM, 'A nick', bis, [])
+
+
+@pytest.fixture
+def player2(bis2: BiS) -> Player:
+    return Player(Job.AST, 'Another nick', bis2, [], priority=0)
+
+
+@pytest.fixture
+def selector(party: Party, player: Player, player2: Player,
+             head_with_upgrade: Piece, weapon: Piece) -> LootSelector:
+    obj = LootSelector(party)
+
+    obj.party.set_player(player)
+    player.bis.set_item(weapon)
+
+    obj.party.set_player(player2)
+    player2.bis.set_item(head_with_upgrade)
+    player2.bis.set_item(weapon)
+
+    return LootSelector(party)
+
+
+@pytest.fixture
+def server(loop: Any, aiohttp_client: Any,
+           config: Configuration, database: Database, selector: LootSelector, party: Party) -> Any:
+    app = setup_service(config, database, selector, party)
+    return loop.run_until_complete(aiohttp_client(app))
+
+
+@pytest.fixture
+def weapon() -> Piece:
+    return Weapon(is_tome=False)

test/test_ariyala.py

@@ -0,0 +1,10 @@
+from typing import List
+
+from service.core.ariyala_parser import AriyalaParser
+from service.models.piece import Piece
+
+
+def test_get(parser: AriyalaParser, bis_link: str, bis_set: List[Piece]) -> None:
+    items = parser.get(bis_link)
+
+    assert items == bis_set

test/test_bis.py

@@ -0,0 +1,20 @@
+from service.models.bis import BiS
+from service.models.piece import Piece
+from service.models.upgrade import Upgrade
+
+
+def test_set_item(bis: BiS, weapon: Piece) -> None:
+    bis.set_item(weapon)
+    assert bis.has_piece(weapon)
+
+
+def test_remove_item(bis: BiS, weapon: Piece) -> None:
+    test_set_item(bis, weapon)
+    bis.remove_item(weapon)
+    assert not bis.has_piece(weapon)
+
+
+def test_upgrades_required(bis: BiS, weapon: Piece, head_with_upgrade: Piece) -> None:
+    bis.set_item(weapon)
+    bis.set_item(head_with_upgrade)
+    assert bis.upgrades_required == {Upgrade.NoUpgrade: 1, Upgrade.GearUpgrade: 1}

test/test_loot_selector.py

@@ -0,0 +1,10 @@
+from service.core.loot_selector import LootSelector
+from service.models.piece import Piece
+from service.models.player import Player
+
+
+def test_suggest_by_need(selector: LootSelector, player: Player, player2: Player, head_with_upgrade: Piece) -> None:
+    assert selector.suggest(head_with_upgrade) == \
+           [player2.player_id_with_counters(head_with_upgrade), player.player_id_with_counters(head_with_upgrade)]
+
+

test/test_party.py

@@ -0,0 +1,95 @@
+from service.core.database import Database
+from service.core.party import Party
+from service.models.piece import Piece
+from service.models.player import Player
+
+
+def test_set_player(party: Party, player: Player) -> None:
+    assert len(party.players) == 0
+
+    party.set_player(player)
+    assert len(party.players) == 1
+
+
+def test_remove_player(party: Party, player: Player) -> None:
+    party.remove_player(player.player_id)
+    assert len(party.players) == 0
+
+    party.set_player(player)
+    party.remove_player(player.player_id)
+    assert len(party.players) == 0
+
+
+def test_set_bis_link(party: Party, player: Player, bis_link: str) -> None:
+    party.set_player(player)
+
+    party.set_bis_link(player.player_id, bis_link)
+    assert player.link == bis_link
+
+
+def test_set_item(party: Party, player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    party.set_player(player)
+
+    party.set_item(player.player_id, weapon)
+    assert abs(player.loot_count(weapon)) == 1
+    assert abs(player.loot_count(head_with_upgrade)) == 0
+
+
+def test_remove_item(party: Party, player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    party.set_player(player)
+
+    party.remove_item(player.player_id, weapon)
+    assert abs(player.loot_count(weapon)) == 0
+    assert abs(player.loot_count(head_with_upgrade)) == 0
+
+    party.set_item(player.player_id, weapon)
+    assert abs(player.loot_count(weapon)) == 1
+    assert abs(player.loot_count(head_with_upgrade)) == 0
+
+    party.remove_item(player.player_id, weapon)
+    assert abs(player.loot_count(weapon)) == 0
+    assert abs(player.loot_count(head_with_upgrade)) == 0
+
+
+def test_set_item_bis(party: Party, player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    party.set_player(player)
+
+    party.set_item_bis(player.player_id, head_with_upgrade)
+    assert player.bis.has_piece(head_with_upgrade)
+    assert not player.bis.has_piece(weapon)
+
+
+def test_remove_item_bis(party: Party, player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    party.set_player(player)
+
+    party.remove_item_bis(player.player_id, head_with_upgrade)
+    assert not player.bis.has_piece(head_with_upgrade)
+    assert not player.bis.has_piece(weapon)
+
+    party.set_item_bis(player.player_id, head_with_upgrade)
+    assert player.bis.has_piece(head_with_upgrade)
+    assert not player.bis.has_piece(weapon)
+
+    party.set_item_bis(player.player_id, weapon)
+    assert player.bis.has_piece(head_with_upgrade)
+    assert player.bis.has_piece(weapon)
+
+    party.remove_item_bis(player.player_id, head_with_upgrade)
+    assert not player.bis.has_piece(head_with_upgrade)
+    assert player.bis.has_piece(weapon)
+
+
+def test_get(party: Party, database: Database, player: Player, head_with_upgrade: Piece, weapon: Piece,
+             bis_link: str) -> None:
+    party.set_player(player)
+    party.set_bis_link(player.player_id, bis_link)
+    party.set_item_bis(player.player_id, head_with_upgrade)
+    party.set_item_bis(player.player_id, weapon)
+    party.set_item(player.player_id, weapon)
+
+    new_party = Party.get(database)
+    assert party.party == new_party.party
+
+    party.remove_player(player.player_id)
+    new_party = Party.get(database)
+    assert party.party == new_party.party

test/test_piece.py

@@ -0,0 +1,13 @@
+from service.models.piece import Piece
+
+
+def test_parse_head(head_with_upgrade: Piece) -> None:
+    assert Piece.get({'piece': 'head', 'is_tome': True}) == head_with_upgrade
+
+
+def test_parse_weapon(weapon: Piece) -> None:
+    assert Piece.get({'piece': 'weapon', 'is_tome': False}) == weapon
+
+
+def test_parse_upgrade(head_with_upgrade: Piece) -> None:
+    assert Piece.get({'piece': head_with_upgrade.upgrade.name, 'is_tome': True}) == head_with_upgrade.upgrade

test/test_player.py

@@ -0,0 +1,73 @@
+from service.models.piece import Piece
+from service.models.player import Player
+
+
+def test_loot_count(player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    assert abs(player.loot_count(head_with_upgrade)) == 0
+    assert abs(player.loot_count(weapon)) == 0
+
+    player.loot.append(head_with_upgrade)
+    assert abs(player.loot_count(head_with_upgrade)) == 1
+    assert abs(player.loot_count(weapon)) == 0
+
+    player.loot.append(weapon)
+    assert abs(player.loot_count(head_with_upgrade)) == 1
+    assert abs(player.loot_count(weapon)) == 1
+
+
+def test_loot_count_bis(player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    assert abs(player.loot_count_bis(head_with_upgrade)) == 0
+    assert abs(player.loot_count_bis(weapon)) == 0
+
+    player.bis.set_item(head_with_upgrade)
+    player.loot.append(head_with_upgrade)
+    assert abs(player.loot_count_bis(head_with_upgrade)) == 1
+    assert abs(player.loot_count_bis(weapon)) == 1
+
+    player.bis.set_item(weapon)
+    assert abs(player.loot_count_bis(head_with_upgrade)) == 1
+    assert abs(player.loot_count_bis(weapon)) == 1
+
+
+def test_loot_count_total(player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    assert abs(player.loot_count_total(head_with_upgrade)) == 0
+    assert abs(player.loot_count_total(weapon)) == 0
+
+    player.loot.append(head_with_upgrade)
+    assert abs(player.loot_count_total(head_with_upgrade)) == 1
+    assert abs(player.loot_count_total(weapon)) == 1
+
+    player.loot.append(weapon)
+    assert abs(player.loot_count_total(head_with_upgrade)) == 2
+    assert abs(player.loot_count_total(weapon)) == 2
+
+
+def test_loot_priority(player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    assert abs(player.priority) == abs(player.loot_priority(head_with_upgrade))
+    assert abs(player.priority) == abs(player.loot_priority(weapon))
+
+    player.loot.append(head_with_upgrade)
+    assert abs(player.priority) == abs(player.loot_priority(head_with_upgrade))
+    assert abs(player.priority) == abs(player.loot_priority(weapon))
+
+    player.loot.append(weapon)
+    assert abs(player.priority) == abs(player.loot_priority(head_with_upgrade))
+    assert abs(player.priority) == abs(player.loot_priority(weapon))
+
+
+def test_is_required(player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    assert not player.is_required(weapon)
+    assert not player.is_required(head_with_upgrade)
+
+    player.bis.set_item(weapon)
+    assert player.is_required(weapon)
+    assert not player.is_required(head_with_upgrade)
+
+    player.loot.append(weapon)
+    assert not player.is_required(weapon)
+    assert not player.is_required(head_with_upgrade)
+
+    player.bis.set_item(head_with_upgrade)
+    assert not player.is_required(weapon)
+    assert player.is_required(head_with_upgrade)
+    assert player.is_required(head_with_upgrade.upgrade)

test/test_view_bis.py

@@ -0,0 +1,67 @@
+from typing import Any, List
+
+from service.api.utils import make_json
+from service.core.party import Party
+from service.models.piece import Piece
+from service.models.player import Player
+
+
+async def test_bis_get(server: Any, party: Party, player: Player, player2: Player,
+                       head_with_upgrade: Piece, weapon: Piece) -> None:
+    party.set_item_bis(player.player_id, weapon)
+    party.set_item_bis(player2.player_id, weapon)
+    party.set_item_bis(player2.player_id, head_with_upgrade)
+
+    response = await server.get('/api/v1/party/bis')
+    assert response.status == 200
+    assert await response.text() == make_json([weapon, weapon, head_with_upgrade], {}, 200)
+
+
+async def test_bis_get_with_filter(server: Any, party: Party, player: Player, player2: Player,
+                                   head_with_upgrade: Piece, weapon: Piece) -> None:
+    party.set_item_bis(player.player_id, weapon)
+    party.set_item_bis(player2.player_id, weapon)
+    party.set_item_bis(player2.player_id, head_with_upgrade)
+
+    response = await server.get('/api/v1/party/bis', params={'nick': player.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([weapon], {'nick': player.nick}, 200)
+
+    response = await server.get('/api/v1/party/bis', params={'nick': player2.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([weapon, head_with_upgrade], {'nick': player2.nick}, 200)
+
+
+async def test_bis_post_add(server: Any, player: Player, head_with_upgrade: Piece) -> None:
+    response = await server.post('/api/v1/party/bis', json={
+        'action': 'add',
+        'piece': head_with_upgrade.name,
+        'is_tome': head_with_upgrade.is_tome,
+        'job': player.job.name,
+        'nick': player.nick
+    })
+    assert response.status == 200
+    assert player.bis.has_piece(head_with_upgrade)
+
+
+async def test_bis_post_remove(server: Any, player: Player, player2: Player, weapon: Piece) -> None:
+    response = await server.post('/api/v1/party/bis', json={
+        'action': 'remove',
+        'piece': weapon.name,
+        'is_tome': weapon.is_tome,
+        'job': player.job.name,
+        'nick': player.nick
+    })
+    assert response.status == 200
+    assert not player.bis.has_piece(weapon)
+    assert player2.bis.has_piece(weapon)
+
+
+async def test_bis_put(server: Any, player: Player, bis_link: str, bis_set: List[Piece]) -> None:
+    response = await server.put('/api/v1/party/bis', json={
+        'job': player.job.name,
+        'link': bis_link,
+        'nick': player.nick
+    })
+    assert response.status == 200
+    assert player.bis.pieces == bis_set

test/test_view_loot.py

@@ -0,0 +1,88 @@
+from typing import Any
+
+from service.api.utils import make_json
+from service.core.party import Party
+from service.models.piece import Piece
+from service.models.player import Player
+
+
+async def test_loot_get(server: Any, party: Party, player: Player, player2: Player, weapon: Piece) -> None:
+    party.set_item(player.player_id, weapon)
+    party.set_item(player2.player_id, weapon)
+
+    response = await server.get('/api/v1/party/loot')
+    assert response.status == 200
+    assert await response.text() == make_json([weapon, weapon], {}, 200)
+
+
+async def test_loot_get_with_filter(server: Any, party: Party, player: Player, player2: Player, weapon: Piece) -> None:
+    party.set_item(player.player_id, weapon)
+    party.set_item(player2.player_id, weapon)
+
+    response = await server.get('/api/v1/party/loot', params={'nick': player.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([weapon], {'nick': player.nick}, 200)
+
+    response = await server.get('/api/v1/party/loot', params={'nick': player2.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([weapon], {'nick': player2.nick}, 200)
+
+
+async def test_loot_post_add(server: Any, player: Player, weapon: Piece) -> None:
+    response = await server.get('/api/v1/party/loot')
+    assert response.status == 200
+    assert await response.text() == make_json([], {}, 200)
+    assert weapon not in player.loot
+
+    response = await server.post('/api/v1/party/loot', json={
+        'action': 'add',
+        'piece': weapon.name,
+        'is_tome': weapon.is_tome,
+        'job': player.job.name,
+        'nick': player.nick
+    })
+    assert response.status == 200
+    assert weapon in player.loot
+
+
+async def test_loot_post_remove(server: Any, player: Player, head_with_upgrade: Piece, weapon: Piece) -> None:
+    assert weapon not in player.loot
+    player.loot.append(weapon)
+    player.loot.append(weapon)
+    assert player.loot.count(weapon) == 2
+
+    response = await server.post('/api/v1/party/loot', json={
+        'action': 'remove',
+        'piece': weapon.name,
+        'is_tome': weapon.is_tome,
+        'job': player.job.name,
+        'nick': player.nick
+    })
+    assert response.status == 200
+    assert player.loot.count(weapon) == 1
+
+    player.loot.append(head_with_upgrade)
+
+    response = await server.post('/api/v1/party/loot', json={
+        'action': 'remove',
+        'piece': weapon.name,
+        'is_tome': weapon.is_tome,
+        'job': player.job.name,
+        'nick': player.nick
+    })
+    assert response.status == 200
+    assert player.loot.count(weapon) == 0
+    assert player.loot.count(head_with_upgrade) == 1
+
+
+async def test_loot_put(server: Any, player: Player, player2: Player, head_with_upgrade: Piece) -> None:
+    response = await server.put('/api/v1/party/loot', json={
+        'is_tome': head_with_upgrade.is_tome,
+        'piece': head_with_upgrade.name
+    })
+    assert response.status == 200
+    assert await response.text() == make_json(
+        [player2.player_id_with_counters(head_with_upgrade), player.player_id_with_counters(head_with_upgrade)],
+        {'is_tome': head_with_upgrade.is_tome, 'piece': head_with_upgrade.name},
+        200
+    )

test/test_view_player.py

@@ -0,0 +1,81 @@
+from typing import Any, List
+
+from service.api.utils import make_json
+from service.core.party import Party
+from service.models.piece import Piece
+from service.models.player import Player
+
+
+async def test_players_get(server: Any, party: Party, player: Player) -> None:
+    party.set_player(player)
+
+    response = await server.get('/api/v1/party')
+    assert response.status == 200
+    assert await response.text() == make_json(party.party, {}, 200)
+
+
+async def test_players_get_with_filter(server: Any, party: Party, player: Player, player2: Player) -> None:
+    party.set_player(player)
+
+    response = await server.get('/api/v1/party', params={'nick': player.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([player], {'nick': player.nick}, 200)
+
+    response = await server.get('/api/v1/party', params={'nick': player2.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([player2], {'nick': player2.nick}, 200)
+
+
+async def test_players_post_add(server: Any, party: Party, player: Player) -> None:
+    party.remove_player(player.player_id)
+
+    response = await server.get('/api/v1/party', params={'nick': player.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([], {'nick': player.nick}, 200)
+
+    response = await server.post('/api/v1/party', json={
+        'action': 'add',
+        'job': player.job.name,
+        'nick': player.nick
+    })
+    assert response.status == 200
+
+    assert player.player_id in party.players
+
+
+async def test_players_post_remove(server: Any, party: Party, player: Player) -> None:
+    response = await server.get('/api/v1/party', params={'nick': player.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([player], {'nick': player.nick}, 200)
+
+    response = await server.post('/api/v1/party', json={
+        'action': 'remove',
+        'job': player.job.name,
+        'nick': player.nick
+    })
+    assert response.status == 200
+
+    response = await server.get('/api/v1/party', params={'nick': player.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([], {'nick': player.nick}, 200)
+
+    assert player.player_id not in party.players
+
+
+async def test_players_post_add_with_link(server: Any, party: Party, player: Player,
+                                          bis_link: str, bis_set: List[Piece]) -> None:
+    party.remove_player(player.player_id)
+
+    response = await server.get('/api/v1/party', params={'nick': player.nick})
+    assert response.status == 200
+    assert await response.text() == make_json([], {'nick': player.nick}, 200)
+
+    response = await server.post('/api/v1/party', json={
+        'action': 'add',
+        'job': player.job.name,
+        'nick': player.nick,
+        'link': bis_link
+    })
+    assert response.status == 200
+
+    assert party.players[player.player_id].bis.pieces == bis_set