1234 lines
50 KiB
C#
1234 lines
50 KiB
C#
using MBN_STOCK_WEBVIEW.LegacyApplication;
|
|
using MMoneyCoderSharp.Data;
|
|
|
|
namespace MBN_STOCK_WEBVIEW.LegacyApplication.Tests;
|
|
|
|
public sealed class LegacyOperatorControllerTests
|
|
{
|
|
[Fact]
|
|
public async Task IndustryTabLoadsSelectorRotatesPairAndAddsTrustedActions()
|
|
{
|
|
var industries = Enumerable.Range(1, 11)
|
|
.Select(index => new IndustrySelection(
|
|
IndustryMarket.Kospi,
|
|
$"업종{index}",
|
|
index.ToString("D3", System.Globalization.CultureInfo.InvariantCulture)))
|
|
.ToArray();
|
|
var workflow = new LegacyIndustrySelectionWorkflow(
|
|
new StaticIndustryService(industries));
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
industryWorkflow: workflow);
|
|
|
|
var loaded = await controller.SelectTabAsync(LegacyOperatorTabId.KospiIndustry);
|
|
Assert.Equal(11, loaded.Industry?.Industries.Count);
|
|
|
|
controller.SelectIndustry(0, doubleClick: true);
|
|
var pair = controller.SelectIndustry(1, doubleClick: true);
|
|
Assert.Equal("업종2", pair.Industry?.FirstIndustry?.IndustryName);
|
|
Assert.Equal("업종1", pair.Industry?.SecondIndustry?.IndustryName);
|
|
|
|
var twoColumn = controller.ActivateIndustryAction("two-column");
|
|
var pairRow = Assert.Single(twoColumn.Playlist);
|
|
Assert.Equal("8018", pairRow.ToPlayoutEntry().CutCode);
|
|
Assert.Equal("업종2-업종1", pairRow.StockName);
|
|
|
|
var paged = controller.ActivateIndustryAction("five-row");
|
|
Assert.Equal("1/3", paged.Playlist[1].PageText);
|
|
Assert.Equal("5074", paged.Playlist[1].ToPlayoutEntry().CutCode);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IndustryComparisonEditChangesOnlyTwoColumnSubjectAndNeverMutatesPlaylistByItself()
|
|
{
|
|
var industries = new[]
|
|
{
|
|
new IndustrySelection(IndustryMarket.Kospi, "전기전자", "013")
|
|
};
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
industryWorkflow: new LegacyIndustrySelectionWorkflow(
|
|
new StaticIndustryService(industries)));
|
|
await controller.SelectTabAsync(LegacyOperatorTabId.KospiIndustry);
|
|
controller.SelectIndustry(0, doubleClick: false);
|
|
|
|
var firstEdit = controller.SetIndustryComparisonText(
|
|
LegacyIndustryComparisonSlot.First,
|
|
"직접 첫째");
|
|
var secondEdit = controller.SetIndustryComparisonText(
|
|
LegacyIndustryComparisonSlot.Second,
|
|
"직접 둘째");
|
|
|
|
Assert.Empty(firstEdit.Playlist);
|
|
Assert.Empty(secondEdit.Playlist);
|
|
Assert.Equal("전기전자",
|
|
controller.ActivateIndustryAction("one-column").Playlist[0].StockName);
|
|
|
|
var pair = controller.ActivateIndustryAction("two-column");
|
|
var pairRow = pair.Playlist[^1];
|
|
Assert.Equal("직접 첫째-직접 둘째", pairRow.StockName);
|
|
Assert.Equal("직접 첫째-직접 둘째", pairRow.PlayoutSelection?.Subject);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IndustryRootDoubleClickMatchesLegacySilentNoOpWhileChildStillAdds()
|
|
{
|
|
var industries = Enumerable.Range(1, 3)
|
|
.Select(index => new IndustrySelection(
|
|
IndustryMarket.Kospi,
|
|
$"업종{index}",
|
|
index.ToString("D3", System.Globalization.CultureInfo.InvariantCulture)))
|
|
.ToArray();
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
industryWorkflow: new LegacyIndustrySelectionWorkflow(
|
|
new StaticIndustryService(industries)));
|
|
await controller.SelectTabAsync(LegacyOperatorTabId.KospiIndustry);
|
|
controller.SelectIndustry(0, doubleClick: true);
|
|
controller.SelectIndustry(1, doubleClick: true);
|
|
|
|
var rootDoubleClick = controller.ActivateIndustrySection(0);
|
|
|
|
Assert.Empty(rootDoubleClick.Playlist);
|
|
Assert.Null(rootDoubleClick.Dialog);
|
|
|
|
var childDoubleClick = controller.ActivateIndustryAction("one-column");
|
|
Assert.Equal("5001", Assert.Single(childDoubleClick.Playlist).SceneAlias);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ThemeTabSearchPreviewSortAndActionRemainCSharpAuthoritative()
|
|
{
|
|
var identity = new ThemeSelectionIdentity(
|
|
ThemeMarket.Krx,
|
|
ThemeSession.NotApplicable,
|
|
"00000001",
|
|
"AI 테마");
|
|
var service = new StaticThemeService(
|
|
identity,
|
|
Enumerable.Range(0, 13)
|
|
.Select(index => new ThemeItemPreview(
|
|
index,
|
|
$"P{index + 1:000000}",
|
|
$"종목{index + 1}"))
|
|
.ToArray());
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
themeWorkflow: new LegacyThemeWorkflow(service));
|
|
await controller.SelectTabAsync(LegacyOperatorTabId.Theme);
|
|
|
|
var searched = await controller.SearchThemesAsync("AI", ThemeSession.PreMarket);
|
|
var resultId = Assert.Single(searched.Theme!.SearchResults).ResultId;
|
|
var selected = await controller.SelectThemeAsync(resultId);
|
|
Assert.Equal(13, selected.Theme?.PreviewItems.Count);
|
|
|
|
controller.SetThemeSort("GAIN_DESC");
|
|
var added = controller.ActivateThemeAction("five-row-current");
|
|
var row = Assert.Single(added.Playlist);
|
|
Assert.Equal("5074", row.ToPlayoutEntry().CutCode);
|
|
Assert.Equal("1/3", row.PageText);
|
|
Assert.Equal("테마", row.MarketText);
|
|
Assert.Equal("AI 테마", row.StockName);
|
|
Assert.Equal("5단 표그래프", row.GraphicType);
|
|
Assert.Equal("테마-현재가(상승률순)", row.Subtype);
|
|
Assert.Equal("테마-현재가(상승률순)", row.RawCutLabel);
|
|
Assert.Equal(
|
|
new MBN_STOCK_WEBVIEW.Core.Playout.Scenes.LegacySceneSelection(
|
|
"PAGED_THEME",
|
|
"AI 테마",
|
|
"GAIN_DESC",
|
|
"CURRENT",
|
|
"00000001"),
|
|
Assert.IsType<MBN_STOCK_WEBVIEW.Core.Playout.Scenes.LegacySceneSelection>(
|
|
row.ToPlayoutEntry().Selection));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task NxtExpectedThemeAction_RemainsClickableAndShowsExactWarningWithoutAdding()
|
|
{
|
|
var identity = new ThemeSelectionIdentity(
|
|
ThemeMarket.Nxt,
|
|
ThemeSession.PreMarket,
|
|
"00000002",
|
|
"AI 테마");
|
|
var service = new StaticThemeService(
|
|
identity,
|
|
[new ThemeItemPreview(0, "X005930", "삼성전자")]);
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
timeProvider: new FixedTimeProvider(new DateTimeOffset(
|
|
2026, 7, 18, 10, 0, 0, TimeSpan.FromHours(9))),
|
|
themeWorkflow: new LegacyThemeWorkflow(
|
|
service,
|
|
() => new DateTimeOffset(2026, 7, 18, 10, 0, 0, TimeSpan.FromHours(9))));
|
|
await controller.SelectTabAsync(LegacyOperatorTabId.Theme);
|
|
var searched = await controller.SearchThemesAsync("AI", ThemeSession.AfterMarket);
|
|
Assert.Equal(
|
|
[ThemeSession.PreMarket, ThemeSession.PreMarket],
|
|
service.SearchSessions);
|
|
var resultId = Assert.Single(searched.Theme!.SearchResults).ResultId;
|
|
var selected = await controller.SelectThemeAsync(resultId);
|
|
Assert.True(Assert.Single(
|
|
selected.Theme!.ActionStates,
|
|
state => state.ActionId == "five-row-expected").IsAvailable);
|
|
|
|
var warned = controller.ActivateThemeAction("five-row-expected");
|
|
|
|
Assert.Empty(warned.Playlist);
|
|
Assert.Equal("NXT는 데이터가 없습니다.", warned.Dialog?.Message);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0, ThemeSession.PreMarket)]
|
|
[InlineData(12, ThemeSession.PreMarket)]
|
|
[InlineData(13, ThemeSession.AfterMarket)]
|
|
[InlineData(23, ThemeSession.AfterMarket)]
|
|
public async Task ThemeActivationAndSearch_DeriveNxtSessionFromControllerLocalTime(
|
|
int localHour,
|
|
ThemeSession expectedSession)
|
|
{
|
|
var identity = new ThemeSelectionIdentity(
|
|
ThemeMarket.Nxt,
|
|
ThemeSession.PreMarket,
|
|
"00000002",
|
|
"AI 테마");
|
|
var service = new StaticThemeService(
|
|
identity,
|
|
[new ThemeItemPreview(0, "X005930", "삼성전자")]);
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
timeProvider: new FixedTimeProvider(new DateTimeOffset(
|
|
2026, 7, 18, localHour, 0, 0, TimeSpan.FromHours(9))),
|
|
themeWorkflow: new LegacyThemeWorkflow(service));
|
|
|
|
await controller.SelectTabAsync(LegacyOperatorTabId.Theme);
|
|
await controller.SearchThemesAsync("AI");
|
|
|
|
Assert.Equal([expectedSession, expectedSession], service.SearchSessions);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task NxtCurrentThemeAction_ProjectsOriginalVisibleColumnsAndKeepsTypedSelection()
|
|
{
|
|
var identity = new ThemeSelectionIdentity(
|
|
ThemeMarket.Nxt,
|
|
ThemeSession.PreMarket,
|
|
"00000002",
|
|
"AI 테마");
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
timeProvider: new FixedTimeProvider(new DateTimeOffset(
|
|
2026, 7, 18, 10, 0, 0, TimeSpan.FromHours(9))),
|
|
themeWorkflow: new LegacyThemeWorkflow(
|
|
new StaticThemeService(
|
|
identity,
|
|
[new ThemeItemPreview(0, "X005930", "삼성전자")]),
|
|
() => new DateTimeOffset(2026, 7, 18, 10, 0, 0, TimeSpan.FromHours(9))));
|
|
var loaded = await controller.SelectTabAsync(LegacyOperatorTabId.Theme);
|
|
await controller.SelectThemeAsync(Assert.Single(loaded.Theme!.SearchResults).ResultId);
|
|
|
|
var added = controller.ActivateThemeAction("six-row-current");
|
|
|
|
var row = Assert.Single(added.Playlist);
|
|
Assert.Equal("테마_NXT", row.MarketText);
|
|
Assert.Equal("AI 테마(NXT)", row.StockName);
|
|
Assert.Equal("6종목 현재가", row.GraphicType);
|
|
Assert.Equal("테마-현재가(입력순)", row.Subtype);
|
|
Assert.Equal("테마-현재가(입력순)", row.RawCutLabel);
|
|
Assert.Equal(
|
|
new MBN_STOCK_WEBVIEW.Core.Playout.Scenes.LegacySceneSelection(
|
|
"PAGED_NXT_THEME",
|
|
"AI 테마(NXT)",
|
|
"PRE_MARKET",
|
|
"INPUT_ORDER",
|
|
"00000002"),
|
|
Assert.IsType<MBN_STOCK_WEBVIEW.Core.Playout.Scenes.LegacySceneSelection>(
|
|
row.ToPlayoutEntry().Selection));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Theme_result_double_click_awaits_preview_and_adds_fixed_current_action_once()
|
|
{
|
|
var identity = new ThemeSelectionIdentity(
|
|
ThemeMarket.Krx,
|
|
ThemeSession.NotApplicable,
|
|
"00000001",
|
|
"AI theme");
|
|
var service = new StaticThemeService(
|
|
identity,
|
|
Enumerable.Range(0, 7)
|
|
.Select(index => new ThemeItemPreview(
|
|
index,
|
|
$"P{index + 1:000000}",
|
|
$"Stock {index + 1}"))
|
|
.ToArray());
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
themeWorkflow: new LegacyThemeWorkflow(service));
|
|
var loaded = await controller.SelectTabAsync(LegacyOperatorTabId.Theme);
|
|
var resultId = Assert.Single(loaded.Theme!.SearchResults).ResultId;
|
|
|
|
var activated = await controller.ActivateThemeResultAsync(resultId);
|
|
|
|
Assert.Equal(1, service.PreviewCalls);
|
|
Assert.Equal(resultId, activated.Theme?.SelectedResultId);
|
|
var row = Assert.Single(activated.Playlist);
|
|
Assert.Equal("5074", row.ToPlayoutEntry().CutCode);
|
|
Assert.Equal("1/2", row.PageText);
|
|
Assert.Equal("INPUT_ORDER", Assert.IsType<
|
|
MBN_STOCK_WEBVIEW.Core.Playout.Scenes.LegacySceneSelection>(
|
|
row.ToPlayoutEntry().Selection).GraphicType);
|
|
Assert.Equal("activate-theme-result", activated.CommandResult?.Command);
|
|
Assert.True(activated.CommandResult?.Succeeded);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ExpertTabSearchPreviewAndPagedActionAddOriginalRow()
|
|
{
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
expertWorkflow: new LegacyExpertWorkflowController(new StaticExpertService()));
|
|
await controller.SelectTabAsync(LegacyOperatorTabId.Expert);
|
|
|
|
var search = await controller.SearchExpertsAsync("전문가");
|
|
var selectionId = Assert.Single(search.Expert!.Search.Results).SelectionId;
|
|
await controller.SelectExpertAsync(selectionId);
|
|
var added = controller.ActivateExpertAction(
|
|
LegacyExpertWorkflowController.ActionId);
|
|
|
|
var row = Assert.Single(added.Playlist);
|
|
Assert.Equal("5074", row.ToPlayoutEntry().CutCode);
|
|
Assert.Equal("1/2", row.PageText);
|
|
Assert.Equal("전문가", row.MarketText);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task TradingHaltTabAddsCurrentAndCandleWithGlobalMovingAverages()
|
|
{
|
|
var controller = new LegacyOperatorController(
|
|
Lookup(),
|
|
tradingHaltWorkflow: new LegacyTradingHaltWorkflowController(
|
|
new StaticTradingHaltService()));
|
|
await controller.SelectTabAsync(LegacyOperatorTabId.TradingHalt);
|
|
var search = await controller.SearchTradingHaltsAsync("");
|
|
var selectionId = Assert.Single(search.TradingHalt!.Results).SelectionId;
|
|
controller.SelectTradingHalt(selectionId);
|
|
|
|
var current = controller.ActivateTradingHaltAction(
|
|
LegacyTradingHaltWorkflowController.CurrentActionId);
|
|
Assert.Equal("5001", Assert.Single(current.Playlist).ToPlayoutEntry().CutCode);
|
|
|
|
controller.SetMovingAverages(ma5: true, ma20: false);
|
|
var candle = controller.ActivateTradingHaltAction(
|
|
LegacyTradingHaltWorkflowController.CandleActionId);
|
|
var candleRow = candle.Playlist[1];
|
|
Assert.Equal("8051", candleRow.ToPlayoutEntry().CutCode);
|
|
Assert.Equal(
|
|
string.Empty,
|
|
Assert.IsType<MBN_STOCK_WEBVIEW.Core.Playout.Scenes.LegacySceneSelection>(
|
|
candleRow.ToPlayoutEntry().Selection).GraphicType);
|
|
Assert.Equal(
|
|
"MA5",
|
|
controller.CreatePlayoutRequest().Playlist[1].Selection!.GraphicType);
|
|
}
|
|
|
|
[Fact]
|
|
public void Tabs_StartInOriginalOrderAndSwapByIdentity()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
|
|
Assert.Equal(
|
|
["해외", "환율", "지수", "코스피", "코스닥", "비교", "테마", "해외종목", "전문가", "정지"],
|
|
controller.Current.Tabs!.Select(tab => tab.Label));
|
|
Assert.Equal(
|
|
LegacyOperatorTabId.Overseas,
|
|
Assert.Single(controller.Current.Tabs!, tab => tab.IsActive).Id);
|
|
|
|
var selected = controller.SelectTab(LegacyOperatorTabId.Theme);
|
|
Assert.Equal(
|
|
LegacyOperatorTabId.Theme,
|
|
Assert.Single(selected.Tabs!, tab => tab.IsActive).Id);
|
|
|
|
var swapped = controller.SwapTabs(
|
|
LegacyOperatorTabId.Theme,
|
|
LegacyOperatorTabId.Exchange);
|
|
Assert.Equal(LegacyOperatorTabId.Theme, swapped.Tabs![1].Id);
|
|
Assert.Equal(LegacyOperatorTabId.Exchange, swapped.Tabs[6].Id);
|
|
Assert.Equal(
|
|
LegacyOperatorTabId.Theme,
|
|
Assert.Single(swapped.Tabs, tab => tab.IsActive).Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task TabHoverSwapUsesExpectedPositionsSoDuplicateDeliveryCannotSwapBack()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
|
|
var first = await controller.SwapTabsAtExpectedPositionsAsync(
|
|
LegacyOperatorTabId.Theme,
|
|
LegacyOperatorTabId.Exchange,
|
|
expectedSourceIndex: 6,
|
|
expectedTargetIndex: 1);
|
|
Assert.Equal(LegacyOperatorTabId.Theme, first.Tabs![1].Id);
|
|
Assert.Equal(LegacyOperatorTabId.Exchange, first.Tabs[6].Id);
|
|
|
|
var revision = first.Revision;
|
|
var duplicate = await controller.SwapTabsAtExpectedPositionsAsync(
|
|
LegacyOperatorTabId.Theme,
|
|
LegacyOperatorTabId.Exchange,
|
|
expectedSourceIndex: 6,
|
|
expectedTargetIndex: 1);
|
|
Assert.Equal(revision, duplicate.Revision);
|
|
Assert.Equal(LegacyOperatorTabId.Theme, duplicate.Tabs![1].Id);
|
|
Assert.Equal(LegacyOperatorTabId.Exchange, duplicate.Tabs[6].Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlaylistKeyboardCommandsUseActiveRowAndBoundaries()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2);
|
|
var rows = controller.Current.Playlist;
|
|
controller.SelectPlaylistRow(rows[0].RowId, control: false, shift: false);
|
|
controller.SelectPlaylistRow(rows[1].RowId, control: true, shift: false);
|
|
|
|
var last = controller.SelectPlaylistBoundary(last: true);
|
|
Assert.True(last.Playlist[0].IsEnabled);
|
|
Assert.True(last.Playlist[2].IsActive);
|
|
Assert.Equal(
|
|
rows.Take(2).Select(row => row.RowId),
|
|
last.Playlist.Where(row => row.IsSelected).Select(row => row.RowId));
|
|
|
|
var toggled = controller.ToggleActivePlaylistRowEnabled();
|
|
Assert.False(toggled.Playlist[2].IsEnabled);
|
|
|
|
var first = controller.SelectPlaylistBoundary(last: false);
|
|
Assert.True(first.Playlist[0].IsActive);
|
|
Assert.Equal(
|
|
rows.Take(2).Select(row => row.RowId),
|
|
first.Playlist.Where(row => row.IsSelected).Select(row => row.RowId));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task FixedCatalogLeafAndSectionAreMaterializedOnlyByCSharp()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
var first = LegacyFixedActionCatalog.Default.GetActions(LegacyFixedMarket.Overseas)[0];
|
|
|
|
var leaf = controller.ActivateFixedAction(first.Id);
|
|
|
|
var row = Assert.Single(leaf.Playlist);
|
|
Assert.Equal("해외지수", row.MarketText);
|
|
Assert.Equal(first.Label, row.StockName);
|
|
Assert.Equal(first.Code, row.ToPlayoutEntry().CutCode);
|
|
Assert.Equal(
|
|
first.Selection.Subject,
|
|
Assert.IsType<MBN_STOCK_WEBVIEW.Core.Playout.Scenes.LegacySceneSelection>(
|
|
row.ToPlayoutEntry().Selection).Subject);
|
|
|
|
var firstSection = LegacyFixedActionCatalog.Default
|
|
.GetSections(LegacyFixedMarket.Overseas)[0];
|
|
var section = await controller.ActivateFixedSection(0);
|
|
Assert.Equal(1 + firstSection.Actions.Count, section.Playlist.Count);
|
|
Assert.Equal(
|
|
firstSection.Actions.Select(action => action.Label),
|
|
section.Playlist.Skip(1).Select(item => item.StockName));
|
|
}
|
|
|
|
[Fact]
|
|
public void FixedCatalogRejectsCrossTabAndUnavailableActionsAtomically()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
var exchange = LegacyFixedActionCatalog.Default
|
|
.GetActions(LegacyFixedMarket.Exchange)[0];
|
|
|
|
var crossTab = controller.ActivateFixedAction(exchange.Id);
|
|
Assert.Empty(crossTab.Playlist);
|
|
Assert.Equal(LegacyOperatorStatusKind.Error, crossTab.StatusKind);
|
|
|
|
var unavailable = LegacyFixedActionCatalog.Default.Actions
|
|
.First(action => !action.Available);
|
|
controller.SelectTab(unavailable.Market switch
|
|
{
|
|
LegacyFixedMarket.Overseas => LegacyOperatorTabId.Overseas,
|
|
LegacyFixedMarket.Exchange => LegacyOperatorTabId.Exchange,
|
|
LegacyFixedMarket.Index => LegacyOperatorTabId.Index,
|
|
_ => throw new InvalidOperationException()
|
|
});
|
|
var blocked = controller.ActivateFixedAction(unavailable.Id);
|
|
Assert.Empty(blocked.Playlist);
|
|
Assert.Equal(unavailable.Prerequisite, blocked.Dialog?.Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void FixedCandleIdentityStaysStableWhileF8SamplesCurrentMovingAverages()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
var candle = LegacyFixedActionCatalog.Default
|
|
.GetActions(LegacyFixedMarket.Index)
|
|
.First(action => action.SupportsMovingAverages);
|
|
controller.SelectTab(LegacyOperatorTabId.Index);
|
|
controller.SetMovingAverages(ma5: false, ma20: true);
|
|
|
|
var state = controller.ActivateFixedAction(candle.Id);
|
|
|
|
Assert.Equal(
|
|
string.Empty,
|
|
Assert.IsType<MBN_STOCK_WEBVIEW.Core.Playout.Scenes.LegacySceneSelection>(
|
|
Assert.Single(state.Playlist).ToPlayoutEntry().Selection).GraphicType);
|
|
Assert.Equal(
|
|
"MA20",
|
|
Assert.Single(controller.CreatePlayoutRequest().Playlist).Selection!.GraphicType);
|
|
Assert.False(state.MovingAverages.Ma5);
|
|
Assert.True(state.MovingAverages.Ma20);
|
|
|
|
controller.SetMovingAverages(ma5: true, ma20: false);
|
|
|
|
Assert.Equal(
|
|
"MA5",
|
|
Assert.Single(controller.CreatePlayoutRequest().Playlist).Selection!.GraphicType);
|
|
Assert.Equal(
|
|
string.Empty,
|
|
Assert.Single(controller.Current.Playlist).PlayoutSelection!.GraphicType);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task EmptyButtonIsNoOpButEmptyEnterSearches()
|
|
{
|
|
var lookup = Lookup();
|
|
var controller = new LegacyOperatorController(lookup);
|
|
|
|
await controller.SearchStocksAsync(string.Empty, LegacySearchTrigger.Button);
|
|
Assert.Equal(0, lookup.CallCount);
|
|
|
|
await controller.SearchStocksAsync(string.Empty, LegacySearchTrigger.Enter);
|
|
Assert.Equal(1, lookup.CallCount);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ExactPointerDoubleClick_AppendsOneLegacyRow()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("삼성", LegacySearchTrigger.Button);
|
|
controller.SelectStock(0);
|
|
|
|
controller.CutPointerDown(1, false, false, 20, 45, 1_000);
|
|
var state = controller.CutPointerDown(1, false, false, 20, 45, 1_400);
|
|
|
|
var row = Assert.Single(state.Playlist);
|
|
Assert.Equal("코스피", row.MarketText);
|
|
Assert.Equal("삼성전자", row.StockName);
|
|
Assert.Equal("1열판기본", row.GraphicType);
|
|
Assert.Equal("현재가", row.Subtype);
|
|
Assert.Equal("005930", row.StockCode);
|
|
Assert.Equal("5001", row.ToPlayoutEntry().CutCode);
|
|
Assert.True(row.IsActive);
|
|
Assert.False(row.IsSelected);
|
|
Assert.Equal(0, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ExactPointerDoubleClick_AllowsZeroBasedWebTimestamp()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("삼성", LegacySearchTrigger.Button);
|
|
controller.SelectStock(0);
|
|
|
|
controller.CutPointerDown(1, false, false, 20, 45, 0);
|
|
var state = controller.CutPointerDown(1, false, false, 20, 45, 499);
|
|
|
|
Assert.Single(state.Playlist);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DifferentPointerPosition_DoesNotCountAsLegacyDoubleClick()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("삼성", LegacySearchTrigger.Button);
|
|
controller.SelectStock(0);
|
|
|
|
controller.CutPointerDown(1, false, false, 20, 45, 1_000);
|
|
var state = controller.CutPointerDown(1, false, false, 21, 45, 1_200);
|
|
|
|
Assert.Empty(state.Playlist);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task NativeSelectionAndLegacyDoubleClickRowsStaySeparateAtShiftEdges()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("삼성", LegacySearchTrigger.Button);
|
|
controller.SelectStock(0);
|
|
|
|
var firstShift = controller.CutPointerDown(2, false, true, 20, 69, 1_000);
|
|
Assert.Equal(
|
|
[0, 1, 2],
|
|
firstShift.CutRows.Where(row => row.IsSelected).Select(row => row.PhysicalIndex));
|
|
|
|
var noDoubleClick = controller.CutPointerDown(2, false, false, 20, 69, 1_400);
|
|
Assert.Empty(noDoubleClick.Playlist);
|
|
|
|
var sameRowShift = controller.CutPointerDown(2, false, true, 21, 69, 2_000);
|
|
Assert.Equal(
|
|
[2],
|
|
sameRowShift.CutRows.Where(row => row.IsSelected).Select(row => row.PhysicalIndex));
|
|
|
|
var stillNoDoubleClick = controller.CutPointerDown(2, false, false, 21, 69, 2_400);
|
|
Assert.Empty(stillNoDoubleClick.Playlist);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ControlAndShiftSelection_DropsInPhysicalOrderAndKeepsDuplicates()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("삼성", LegacySearchTrigger.Button);
|
|
controller.SelectStock(0);
|
|
controller.CutPointerDown(0, false, false, 1, 1, 1_000);
|
|
controller.CutPointerDown(2, true, false, 1, 47, 2_000);
|
|
controller.CutPointerDown(1, true, true, 1, 24, 3_000);
|
|
|
|
var first = controller.DropSelectedCutsOnPlaylist();
|
|
var second = controller.DropSelectedCutsOnPlaylist();
|
|
|
|
Assert.Equal(3, first.Playlist.Count);
|
|
Assert.Equal(6, second.Playlist.Count);
|
|
Assert.Equal(
|
|
["예상체결가", "현재가", "시간외단일가"],
|
|
first.Playlist.Select(row => row.Subtype));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SameRowShiftStillDropsTheNativeListViewSelection()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("삼성", LegacySearchTrigger.Button);
|
|
controller.SelectStock(0);
|
|
controller.CutPointerDown(1, false, false, 1, 24, 1_000);
|
|
controller.CutPointerDown(1, false, true, 2, 24, 2_000);
|
|
|
|
var state = controller.DropSelectedCutsOnPlaylist();
|
|
|
|
Assert.Equal("현재가", Assert.Single(state.Playlist).Subtype);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task NxtOnlyAllowsCurrentAndShowsOriginalWarning()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("넥스트", LegacySearchTrigger.Button);
|
|
controller.SelectStock(1);
|
|
controller.CutPointerDown(0, false, false, 1, 1, 1_000);
|
|
var warning = controller.DropSelectedCutsOnPlaylist();
|
|
|
|
Assert.Empty(warning.Playlist);
|
|
Assert.Equal("NXT는 제공하지 않습니다.", warning.Dialog?.Message);
|
|
|
|
controller.DismissDialog();
|
|
controller.CutPointerDown(1, false, false, 1, 24, 2_000);
|
|
var accepted = controller.DropSelectedCutsOnPlaylist();
|
|
Assert.Equal("N5001", Assert.Single(accepted.Playlist).ToPlayoutEntry().CutCode);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task NxtMultiSelection_PausesAtEachOriginalModalBeforeContinuing()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("넥스트", LegacySearchTrigger.Button);
|
|
controller.SelectStock(1);
|
|
controller.CutPointerDown(0, false, false, 1, 1, 1_000);
|
|
controller.CutPointerDown(1, true, false, 1, 24, 2_000);
|
|
controller.CutPointerDown(2, true, false, 1, 47, 3_000);
|
|
|
|
var firstWarning = controller.DropSelectedCutsOnPlaylist();
|
|
Assert.Empty(firstWarning.Playlist);
|
|
Assert.Equal("NXT는 제공하지 않습니다.", firstWarning.Dialog?.Message);
|
|
|
|
var secondWarning = controller.DismissDialog();
|
|
Assert.Equal("N5001", Assert.Single(secondWarning.Playlist).ToPlayoutEntry().CutCode);
|
|
Assert.Equal("NXT는 제공하지 않습니다.", secondWarning.Dialog?.Message);
|
|
|
|
var finished = controller.DismissDialog();
|
|
Assert.Single(finished.Playlist);
|
|
Assert.Null(finished.Dialog);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task NxtSeparatorStillShowsOriginalWarning()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("넥스트", LegacySearchTrigger.Button);
|
|
controller.SelectStock(1);
|
|
controller.CutPointerDown(3, false, false, 1, 70, 1_000);
|
|
|
|
var warning = controller.DropSelectedCutsOnPlaylist();
|
|
|
|
Assert.Empty(warning.Playlist);
|
|
Assert.Equal("NXT는 제공하지 않습니다.", warning.Dialog?.Message);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task NewSearchClearsStockSelectionButNotCutCatalogOrPlaylist()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("삼성", LegacySearchTrigger.Button);
|
|
controller.SelectStock(0);
|
|
controller.CutPointerDown(1, false, false, 1, 24, 1_000);
|
|
controller.DropSelectedCutsOnPlaylist();
|
|
|
|
var state = await controller.SearchStocksAsync("다시", LegacySearchTrigger.Button);
|
|
|
|
Assert.Null(state.SelectedStockIndex);
|
|
Assert.Equal(33, state.CutRows.Count);
|
|
Assert.Single(state.Playlist);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlaylistPlainControlAndControlShiftSelectionMatchMainFormRules()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4, 5);
|
|
var ids = controller.Current.Playlist.Select(row => row.RowId).ToArray();
|
|
|
|
controller.SelectPlaylistRow(ids[1], control: false, shift: false);
|
|
controller.SelectPlaylistRow(ids[3], control: true, shift: false);
|
|
controller.SelectPlaylistRow(ids[3], control: true, shift: false);
|
|
var state = controller.SelectPlaylistRow(ids[4], control: true, shift: true);
|
|
|
|
Assert.Equal(
|
|
[ids[1], ids[3], ids[4]],
|
|
state.Playlist.Where(row => row.IsSelected).Select(row => row.RowId));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlaylistShiftUsesPreviousActiveRowAndMovesItsRangeAnchor()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4, 5);
|
|
var ids = controller.Current.Playlist.Select(row => row.RowId).ToArray();
|
|
|
|
controller.SelectPlaylistRow(ids[1], control: false, shift: false);
|
|
var firstRange = controller.SelectPlaylistRow(ids[3], control: false, shift: true);
|
|
Assert.Equal(
|
|
ids[1..4],
|
|
firstRange.Playlist.Where(row => row.IsSelected).Select(row => row.RowId));
|
|
|
|
var movedRange = controller.SelectPlaylistRow(ids[4], control: false, shift: true);
|
|
Assert.Equal(
|
|
ids[3..5],
|
|
movedRange.Playlist.Where(row => row.IsSelected).Select(row => row.RowId));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task FirstPlaylistShiftStartsAtOriginalZeroCursor()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2);
|
|
var ids = controller.Current.Playlist.Select(row => row.RowId).ToArray();
|
|
|
|
var state = controller.SelectPlaylistRow(ids[2], control: false, shift: true);
|
|
|
|
Assert.All(state.Playlist, row => Assert.True(row.IsSelected));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CheckboxActivationChangesF8CandidateWithoutReplacingDeleteSelection()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2);
|
|
var ids = controller.Current.Playlist.Select(row => row.RowId).ToArray();
|
|
controller.SelectPlaylistRow(ids[0], control: false, shift: false);
|
|
controller.SelectPlaylistRow(ids[1], control: true, shift: false);
|
|
|
|
var state = controller.ActivatePlaylistRow(ids[2]);
|
|
|
|
Assert.Equal(
|
|
ids[..2],
|
|
state.Playlist.Where(row => row.IsSelected).Select(row => row.RowId));
|
|
Assert.Equal(ids[2], Assert.Single(state.Playlist, row => row.IsActive).RowId);
|
|
Assert.Equal(2, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CheckboxActivationDoesNotMoveTheFollowingShiftSelectionAnchor()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4);
|
|
var ids = controller.Current.Playlist.Select(row => row.RowId).ToArray();
|
|
controller.SelectPlaylistRow(ids[1], control: false, shift: false);
|
|
|
|
controller.ActivatePlaylistRow(ids[3]);
|
|
var range = controller.SelectPlaylistRow(ids[2], control: false, shift: true);
|
|
|
|
Assert.Equal(
|
|
ids[1..3],
|
|
range.Playlist.Where(row => row.IsSelected).Select(row => row.RowId));
|
|
Assert.Equal(ids[2], Assert.Single(range.Playlist, row => row.IsActive).RowId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task HomeAndEndChangeOnlyTheF8CandidateAndKeepProgramPageProjection()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4);
|
|
var rows = controller.Current.Playlist;
|
|
controller.SelectPlaylistRow(rows[1].RowId, control: false, shift: false);
|
|
controller.SelectPlaylistRow(rows[3].RowId, control: true, shift: false);
|
|
controller.ReflectSuccessfulPlayout(
|
|
rows[1].RowId,
|
|
pageIndexZeroBased: 1,
|
|
pageCount: 3,
|
|
synchronizeOperatorSelection: false);
|
|
|
|
var home = controller.SelectPlaylistBoundary(last: false);
|
|
Assert.Equal(0, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
Assert.Equal("2/3", home.Playlist[1].PageText);
|
|
Assert.True(home.Playlist[0].IsActive);
|
|
Assert.Equal(
|
|
[rows[1].RowId, rows[3].RowId],
|
|
home.Playlist.Where(row => row.IsSelected).Select(row => row.RowId));
|
|
|
|
var end = controller.SelectPlaylistBoundary(last: true);
|
|
Assert.Equal(3, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
Assert.Equal("2/3", end.Playlist[1].PageText);
|
|
Assert.True(end.Playlist[3].IsActive);
|
|
|
|
var shift = controller.SelectPlaylistRow(
|
|
rows[2].RowId,
|
|
control: false,
|
|
shift: true);
|
|
Assert.Equal(
|
|
[rows[1].RowId, rows[2].RowId],
|
|
shift.Playlist.Where(row => row.IsSelected).Select(row => row.RowId));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task FirstAppendedRowIsAnF8CandidateButNotAnImplicitDeleteSelection()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0);
|
|
var before = controller.Current;
|
|
|
|
Assert.True(Assert.Single(before.Playlist).IsActive);
|
|
Assert.DoesNotContain(before.Playlist, row => row.IsSelected);
|
|
Assert.Equal(0, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
|
|
var after = controller.DeleteSelectedPlaylistRows();
|
|
Assert.Equal(before.Revision, after.Revision);
|
|
Assert.Single(after.Playlist);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlaylistEnabledSupportsIndividualToggleAndAllRows()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2);
|
|
var ids = controller.Current.Playlist.Select(row => row.RowId).ToArray();
|
|
|
|
controller.SetPlaylistRowEnabled(ids[0], false);
|
|
var toggled = controller.TogglePlaylistRowEnabled(ids[1]);
|
|
Assert.False(toggled.Playlist[0].IsEnabled);
|
|
Assert.False(toggled.Playlist[1].IsEnabled);
|
|
Assert.True(toggled.Playlist[2].IsEnabled);
|
|
|
|
var disabled = controller.SetAllPlaylistRowsEnabled(false);
|
|
Assert.All(disabled.Playlist, row => Assert.False(row.IsEnabled));
|
|
|
|
var enabled = controller.SetAllPlaylistRowsEnabled(true);
|
|
Assert.All(enabled.Playlist, row => Assert.True(row.IsEnabled));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DeleteSelectedRowsPreservesRemainingPhysicalOrderAndClearsSelection()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4);
|
|
var initial = controller.Current.Playlist.ToArray();
|
|
|
|
controller.SelectPlaylistRow(initial[1].RowId, control: false, shift: false);
|
|
controller.SelectPlaylistRow(initial[3].RowId, control: true, shift: false);
|
|
var state = controller.DeleteSelectedPlaylistRows();
|
|
|
|
Assert.Equal(
|
|
[initial[0].RowId, initial[2].RowId],
|
|
state.Playlist.Select(row => row.RowId));
|
|
Assert.DoesNotContain(state.Playlist, row => row.IsSelected);
|
|
Assert.Equal(initial[2].RowId, Assert.Single(state.Playlist, row => row.IsActive).RowId);
|
|
Assert.Equal(1, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DeletePreservesAnIndependentCheckboxCandidateByStableIdentity()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4);
|
|
var initial = controller.Current.Playlist.ToArray();
|
|
controller.SelectPlaylistRow(initial[0].RowId, control: false, shift: false);
|
|
controller.SelectPlaylistRow(initial[1].RowId, control: true, shift: false);
|
|
controller.ActivatePlaylistRow(initial[3].RowId);
|
|
|
|
var state = controller.DeleteSelectedPlaylistRows();
|
|
|
|
Assert.Equal(
|
|
[initial[2].RowId, initial[3].RowId],
|
|
state.Playlist.Select(row => row.RowId));
|
|
Assert.DoesNotContain(state.Playlist, row => row.IsSelected);
|
|
Assert.Equal(initial[3].RowId, Assert.Single(state.Playlist, row => row.IsActive).RowId);
|
|
Assert.Equal(1, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DeleteActiveCandidateChoosesTheNextSurvivorThenThePreviousAtEnd()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4);
|
|
var initial = controller.Current.Playlist.ToArray();
|
|
controller.SelectPlaylistRow(initial[1].RowId, control: false, shift: false);
|
|
|
|
var afterMiddle = controller.DeleteSelectedPlaylistRows();
|
|
|
|
Assert.Equal(initial[2].RowId, Assert.Single(afterMiddle.Playlist, row => row.IsActive).RowId);
|
|
Assert.Equal(1, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
|
|
controller.SelectPlaylistRow(initial[3].RowId, control: false, shift: false);
|
|
var afterLast = controller.DeleteSelectedPlaylistRows();
|
|
|
|
Assert.Equal(initial[2].RowId, Assert.Single(afterLast.Playlist, row => row.IsActive).RowId);
|
|
Assert.Equal(1, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ShiftSelectionAndDeleteAreNotLimitedToTheOriginalHundredRowBuffers()
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("삼성", LegacySearchTrigger.Button);
|
|
controller.SelectStock(0);
|
|
controller.CutPointerDown(1, false, false, 1, 24, 1_000);
|
|
for (var index = 0; index < 101; index++)
|
|
{
|
|
controller.DropSelectedCutsOnPlaylist();
|
|
}
|
|
|
|
var rows = controller.Current.Playlist;
|
|
Assert.Equal(101, rows.Count);
|
|
controller.SelectPlaylistRow(rows[0].RowId, control: false, shift: false);
|
|
var selected = controller.SelectPlaylistRow(
|
|
rows[^1].RowId,
|
|
control: false,
|
|
shift: true);
|
|
Assert.Equal(101, selected.Playlist.Count(row => row.IsSelected));
|
|
|
|
var deleted = controller.DeleteSelectedPlaylistRows();
|
|
|
|
Assert.Empty(deleted.Playlist);
|
|
Assert.Throws<InvalidOperationException>(() => controller.CreatePlayoutRequest());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DeleteAllRowsClearsPlaylistAndSelectionState()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2);
|
|
controller.SelectPlaylistRow(
|
|
controller.Current.Playlist[1].RowId,
|
|
control: false,
|
|
shift: false);
|
|
|
|
var empty = controller.DeleteAllPlaylistRows();
|
|
Assert.Empty(empty.Playlist);
|
|
|
|
var unchangedRevision = empty.Revision;
|
|
var stillEmpty = controller.DeleteAllPlaylistRows();
|
|
Assert.Equal(unchangedRevision, stillEmpty.Revision);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task FirstAppendAfterDeleteAllReestablishesTheVisibleF8Candidate()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1);
|
|
controller.DeleteAllPlaylistRows();
|
|
|
|
controller.CutPointerDown(2, false, false, 1, 47, 10_000);
|
|
var state = controller.DropSelectedCutsOnPlaylist();
|
|
|
|
var row = Assert.Single(state.Playlist);
|
|
Assert.True(row.IsActive);
|
|
Assert.False(row.IsSelected);
|
|
Assert.Equal(0, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task MoveUsesOnlyActiveRowAndCollapsesMultiSelectionToMovedRow()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4);
|
|
var initial = controller.Current.Playlist.ToArray();
|
|
|
|
controller.SelectPlaylistRow(initial[0].RowId, control: false, shift: false);
|
|
controller.SelectPlaylistRow(initial[2].RowId, control: true, shift: false);
|
|
var moved = controller.MoveSelectedPlaylistRows(LegacyPlaylistMoveDirection.Up);
|
|
|
|
Assert.Equal(
|
|
[initial[0].RowId, initial[2].RowId, initial[1].RowId, initial[3].RowId],
|
|
moved.Playlist.Select(row => row.RowId));
|
|
Assert.Equal(
|
|
initial[2].RowId,
|
|
Assert.Single(moved.Playlist, row => row.IsSelected).RowId);
|
|
Assert.Equal(initial[2].ToPlayoutEntry(), moved.Playlist[1].ToPlayoutEntry());
|
|
Assert.Equal(initial[2].PageText, moved.Playlist[1].PageText);
|
|
Assert.Equal(initial[2].RawCutLabel, moved.Playlist[1].RawCutLabel);
|
|
Assert.Equal(1, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
|
|
var restored = controller.MoveSelectedPlaylistRows(LegacyPlaylistMoveDirection.Down);
|
|
Assert.Equal(initial.Select(row => row.RowId), restored.Playlist.Select(row => row.RowId));
|
|
Assert.Equal(
|
|
initial[2].RowId,
|
|
Assert.Single(restored.Playlist, row => row.IsSelected).RowId);
|
|
Assert.Equal(2, controller.CreatePlayoutRequest().SelectedIndexZeroBased);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task MoveAtBoundaryIsNoOp()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1);
|
|
var first = controller.Current.Playlist[0];
|
|
controller.SelectPlaylistRow(first.RowId, control: false, shift: false);
|
|
var before = controller.Current;
|
|
|
|
var after = controller.MoveSelectedPlaylistRows(LegacyPlaylistMoveDirection.Up);
|
|
|
|
Assert.Equal(before.Revision, after.Revision);
|
|
Assert.Equal(
|
|
before.Playlist.Select(row => row.RowId),
|
|
after.Playlist.Select(row => row.RowId));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlaylistDragMovesOnlySourceRowCollapsesSelectionAndIsIdempotent()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4, 5, 6);
|
|
var initial = controller.Current.Playlist.ToArray();
|
|
|
|
controller.SelectPlaylistRow(initial[1].RowId, control: false, shift: false);
|
|
controller.SelectPlaylistRow(initial[3].RowId, control: true, shift: false);
|
|
var moved = controller.ReorderPlaylistRows(
|
|
initial[3].RowId,
|
|
initial[5].RowId,
|
|
LegacyDragDropPosition.Before);
|
|
|
|
Assert.Equal(
|
|
[
|
|
initial[0].RowId,
|
|
initial[1].RowId,
|
|
initial[2].RowId,
|
|
initial[4].RowId,
|
|
initial[3].RowId,
|
|
initial[5].RowId
|
|
],
|
|
moved.Playlist.Select(row => row.RowId));
|
|
Assert.Equal(
|
|
initial[3].RowId,
|
|
Assert.Single(moved.Playlist, row => row.IsSelected).RowId);
|
|
Assert.Equal(
|
|
initial[3].RowId,
|
|
Assert.Single(moved.Playlist, row => row.IsActive).RowId);
|
|
|
|
var revision = moved.Revision;
|
|
var duplicate = controller.ReorderPlaylistRows(
|
|
initial[3].RowId,
|
|
initial[5].RowId,
|
|
LegacyDragDropPosition.Before);
|
|
Assert.Equal(revision, duplicate.Revision);
|
|
Assert.Equal(
|
|
moved.Playlist.Select(row => row.RowId),
|
|
duplicate.Playlist.Select(row => row.RowId));
|
|
Assert.Equal(
|
|
initial[3].RowId,
|
|
Assert.Single(duplicate.Playlist, row => row.IsSelected).RowId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlaylistDragFromUnselectedRowMovesOnlyThatRowAndSelectsIt()
|
|
{
|
|
var controller = await ControllerWithPlaylistAsync(0, 1, 2, 4);
|
|
var initial = controller.Current.Playlist.ToArray();
|
|
controller.SelectPlaylistRow(initial[0].RowId, control: false, shift: false);
|
|
controller.SelectPlaylistRow(initial[1].RowId, control: true, shift: false);
|
|
|
|
var moved = controller.ReorderPlaylistRows(
|
|
initial[3].RowId,
|
|
initial[0].RowId,
|
|
LegacyDragDropPosition.Before);
|
|
|
|
Assert.Equal(
|
|
[initial[3].RowId, initial[0].RowId, initial[1].RowId, initial[2].RowId],
|
|
moved.Playlist.Select(row => row.RowId));
|
|
Assert.Equal(
|
|
initial[3].RowId,
|
|
Assert.Single(moved.Playlist, row => row.IsSelected).RowId);
|
|
}
|
|
|
|
private static async Task<LegacyOperatorController> ControllerWithPlaylistAsync(
|
|
params int[] physicalCutRows)
|
|
{
|
|
var controller = new LegacyOperatorController(Lookup());
|
|
await controller.SearchStocksAsync("삼성", LegacySearchTrigger.Button);
|
|
controller.SelectStock(0);
|
|
|
|
var timestamp = 1_000L;
|
|
foreach (var physicalCutRow in physicalCutRows)
|
|
{
|
|
controller.CutPointerDown(
|
|
physicalCutRow,
|
|
control: false,
|
|
shift: false,
|
|
x: 1,
|
|
y: physicalCutRow * 23,
|
|
timestampMilliseconds: timestamp);
|
|
controller.DropSelectedCutsOnPlaylist();
|
|
timestamp += 1_000;
|
|
}
|
|
|
|
return controller;
|
|
}
|
|
|
|
private static FakeLookup Lookup() => new(new LegacyStockSearchData(
|
|
"query",
|
|
["삼성전자", "넥스트(NXT)"],
|
|
[
|
|
new LegacyStockIdentity(LegacyDomesticStockMarket.Kospi, "삼성전자", "005930"),
|
|
new LegacyStockIdentity(LegacyDomesticStockMarket.NxtKospi, "넥스트(NXT)", "A00001")
|
|
]));
|
|
|
|
private sealed class FakeLookup : ILegacyStockLookup
|
|
{
|
|
private readonly LegacyStockSearchData _result;
|
|
|
|
public FakeLookup(LegacyStockSearchData result)
|
|
{
|
|
_result = result;
|
|
}
|
|
|
|
public int CallCount { get; private set; }
|
|
|
|
public Task<LegacyStockSearchData> SearchAsync(
|
|
string query,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
CallCount++;
|
|
return Task.FromResult(_result);
|
|
}
|
|
}
|
|
|
|
private sealed class FixedTimeProvider(DateTimeOffset localNow) : TimeProvider
|
|
{
|
|
private static readonly TimeZoneInfo KoreaStandardTime = TimeZoneInfo.CreateCustomTimeZone(
|
|
"FixedKst",
|
|
TimeSpan.FromHours(9),
|
|
"Fixed KST",
|
|
"Fixed KST");
|
|
|
|
public override DateTimeOffset GetUtcNow() => localNow.ToUniversalTime();
|
|
|
|
public override TimeZoneInfo LocalTimeZone => KoreaStandardTime;
|
|
}
|
|
|
|
private sealed class StaticIndustryService : IIndustrySelectionService
|
|
{
|
|
private readonly IReadOnlyList<IndustrySelection> _rows;
|
|
|
|
public StaticIndustryService(IReadOnlyList<IndustrySelection> rows)
|
|
{
|
|
_rows = rows;
|
|
}
|
|
|
|
public Task<IReadOnlyList<IndustrySelection>> GetAsync(
|
|
IndustryMarket market,
|
|
CancellationToken cancellationToken = default) => Task.FromResult(_rows);
|
|
}
|
|
|
|
private sealed class StaticThemeService : IThemeSelectionService
|
|
{
|
|
private readonly ThemeSelectionIdentity _identity;
|
|
private readonly IReadOnlyList<ThemeItemPreview> _items;
|
|
|
|
public StaticThemeService(
|
|
ThemeSelectionIdentity identity,
|
|
IReadOnlyList<ThemeItemPreview> items)
|
|
{
|
|
_identity = identity;
|
|
_items = items;
|
|
}
|
|
|
|
public int PreviewCalls { get; private set; }
|
|
|
|
public List<ThemeSession> SearchSessions { get; } = [];
|
|
|
|
public Task<ThemeSearchResult> SearchAsync(
|
|
string query,
|
|
ThemeSession nxtSession,
|
|
int maximumResults = LegacyThemeSelectionService.DefaultMaximumResults,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
SearchSessions.Add(nxtSession);
|
|
var identity = _identity.Market == ThemeMarket.Nxt
|
|
? _identity with { Session = nxtSession }
|
|
: _identity;
|
|
return Task.FromResult(
|
|
new ThemeSearchResult(
|
|
query,
|
|
nxtSession,
|
|
DateTimeOffset.UtcNow,
|
|
[new ThemeSelectorItem(
|
|
identity,
|
|
identity.Market == ThemeMarket.Krx
|
|
? DataSourceKind.Oracle
|
|
: DataSourceKind.MariaDb)],
|
|
false));
|
|
}
|
|
|
|
public Task<ThemePreviewResult> PreviewAsync(
|
|
ThemeSelectionIdentity identity,
|
|
int maximumItems = LegacyThemeSelectionService.DefaultMaximumPreviewItems,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
PreviewCalls++;
|
|
return Task.FromResult(
|
|
new ThemePreviewResult(
|
|
identity,
|
|
DateTimeOffset.UtcNow,
|
|
_items,
|
|
false));
|
|
}
|
|
}
|
|
|
|
private sealed class StaticExpertService : IExpertSelectionService
|
|
{
|
|
private static readonly ExpertSelectionIdentity Identity = new("0001", "전문가A");
|
|
|
|
public Task<ExpertSearchResult> SearchAsync(
|
|
string query = "",
|
|
int maximumResults = LegacyExpertSelectionService.DefaultMaximumResults,
|
|
CancellationToken cancellationToken = default) => Task.FromResult(
|
|
new ExpertSearchResult(
|
|
query.Trim(),
|
|
DateTimeOffset.UtcNow,
|
|
[new ExpertSelectorItem(Identity, DataSourceKind.Oracle)],
|
|
false));
|
|
|
|
public Task<ExpertPreviewResult> PreviewAsync(
|
|
ExpertSelectionIdentity identity,
|
|
int maximumItems = LegacyExpertSelectionService.DefaultMaximumPreviewItems,
|
|
CancellationToken cancellationToken = default) => Task.FromResult(
|
|
new ExpertPreviewResult(
|
|
Identity,
|
|
DateTimeOffset.UtcNow,
|
|
Enumerable.Range(1, 6)
|
|
.Select(index => new ExpertRecommendationPreview(
|
|
index,
|
|
index.ToString("D6", System.Globalization.CultureInfo.InvariantCulture),
|
|
$"추천{index}",
|
|
10_000m + index))
|
|
.ToArray(),
|
|
false));
|
|
}
|
|
|
|
private sealed class StaticTradingHaltService : ITradingHaltSelectionService
|
|
{
|
|
public Task<TradingHaltSelectionResult> SearchAsync(
|
|
string query = "",
|
|
int maximumResults = LegacyTradingHaltSelectionService.DefaultMaximumResults,
|
|
CancellationToken cancellationToken = default) => Task.FromResult(
|
|
new TradingHaltSelectionResult(
|
|
query.Trim(),
|
|
DateTimeOffset.UtcNow,
|
|
[new TradingHaltSelection(TradingHaltMarket.Kospi, "005930", "삼성전자")],
|
|
false));
|
|
}
|
|
}
|